Merge pull request #41 from eigerco/feat/in-memory-api

feat(sdk): in-memory api

Author: zeapoz

Cargo.lock

@@ -19,7 +19,6 @@ clap = { workspace = true, features = ["derive", "env"] }
 console-subscriber = { workspace = true, optional = true }
 dotenvy = { workspace = true }
 eyre = { workspace = true }
-rustls = { workspace = true, features = ["ring"] }
 tokio = { workspace = true, features = [
   "rt-multi-thread",
   "macros",

crates/zair-cli/Cargo.toml

@@ -49,9 +49,7 @@ fn init_tracing() -> eyre::Result<()> {
 )]
 async fn main() -> eyre::Result<()> {
     // Initialize rustls crypto provider (required for TLS connections)
-    rustls::crypto::ring::default_provider()
-        .install_default()
-        .map_err(|e| eyre::eyre!("Failed to install rustls crypto provider: {e:?}"))?;
+    zair_sdk::install_default_crypto_provider()?;
 
     // Load .env file (fails silently if not found)
     let _ = dotenvy::dotenv();

crates/zair-cli/src/main.rs

@@ -25,7 +25,7 @@ pub fn map_sapling_user_positions(
 
 /// # Errors
 /// Returns an error if `gap_idx` is out of bounds for the given nullifiers.
-pub fn sapling_gap_bounds(
+pub const fn sapling_gap_bounds(
     nullifiers: &[Nullifier],
     gap_idx: usize,
 ) -> Result<(Nullifier, Nullifier), MerklePathError> {

crates/zair-nonmembership/src/pool/sapling.rs

@@ -465,7 +465,7 @@ mod tests {
         }};
     }
 
-    fn make_leaf(value: u8) -> NonMembershipNode {
+    const fn make_leaf(value: u8) -> NonMembershipNode {
         let mut bytes = [0u8; 32];
         bytes[0] = value;
         NonMembershipNode::new(bytes)

crates/zair-nonmembership/src/sparse/sapling.rs

@@ -12,22 +12,19 @@ const NATIVE_INSTANCE_COUNT: usize = 7;
 /// Number of public instance scalars for the SHA-256 value commitment scheme.
 const SHA256_INSTANCE_COUNT: usize = 13;
 
-pub(crate) fn base_from_repr(bytes: [u8; 32]) -> Result<pallas::Base, ClaimProofError> {
+pub fn base_from_repr(bytes: [u8; 32]) -> Result<pallas::Base, ClaimProofError> {
     Option::<pallas::Base>::from(pallas::Base::from_repr(bytes))
         .ok_or(ClaimProofError::NonCanonicalBase)
 }
 
 #[cfg(feature = "prove")]
-pub(crate) fn scalar_from_repr(bytes: [u8; 32]) -> Result<pallas::Scalar, ClaimProofError> {
+pub fn scalar_from_repr(bytes: [u8; 32]) -> Result<pallas::Scalar, ClaimProofError> {
     Option::<pallas::Scalar>::from(pallas::Scalar::from_repr(bytes))
         .ok_or(ClaimProofError::NonCanonicalScalar)
 }
 
 #[cfg(feature = "prove")]
-pub(crate) fn target_id_slice(
-    target_id: &[u8; 32],
-    target_id_len: u8,
-) -> Result<&[u8], ClaimProofError> {
+pub fn target_id_slice(target_id: &[u8; 32], target_id_len: u8) -> Result<&[u8], ClaimProofError> {
     let target = target_id
         .get(..usize::from(target_id_len))
         .ok_or(ClaimProofError::InvalidTargetIdLength)?;
@@ -36,7 +33,7 @@ pub(crate) fn target_id_slice(
 }
 
 #[cfg(feature = "prove")]
-pub(crate) fn point_from_bytes(bytes: [u8; 32]) -> Result<pallas::Affine, ClaimProofError> {
+pub fn point_from_bytes(bytes: [u8; 32]) -> Result<pallas::Affine, ClaimProofError> {
     let p = Option::<pallas::Point>::from(pallas::Point::from_bytes(&bytes))
         .ok_or(ClaimProofError::InvalidPoint)?;
     if bool::from(p.is_identity()) {
@@ -57,7 +54,7 @@ fn coords_or_zero(p: pallas::Point) -> (pallas::Base, pallas::Base) {
     }
 }
 
-pub(crate) fn to_instance(
+pub fn to_instance(
     note_commitment_root: [u8; 32],
     cv: Option<[u8; 32]>,
     cv_sha256: Option<[u8; 32]>,

crates/zair-orchard-proofs/src/instance.rs

@@ -13,7 +13,7 @@ use crate::error::ClaimProofError;
 use crate::types::ValueCommitmentScheme;
 
 #[derive(Debug)]
-pub(crate) struct Keys {
+pub struct Keys {
     pub(crate) vk: VerifyingKey<vesta::Affine>,
     #[cfg_attr(feature = "verify", allow(dead_code))]
     pub(crate) pk: plonk::ProvingKey<vesta::Affine>,
@@ -51,7 +51,7 @@ struct CacheKey {
     target_id_len: u8,
 }
 
-pub(crate) fn keys_for(
+pub fn keys_for(
     params: &Params<vesta::Affine>,
     scheme: ValueCommitmentScheme,
     target_id: [u8; 32],

crates/zair-orchard-proofs/src/keys.rs

@@ -121,3 +121,23 @@ pub fn load_parameters(
 
     Ok(ClaimParameters(params))
 }
+
+/// Load parameters from in-memory bytes.
+///
+/// # Arguments
+/// * `bytes` - Proving key bytes
+/// * `checked` - If true, verify the parameters (slower but safer)
+///
+/// # Errors
+/// Returns an error if reading or parsing fails.
+pub fn load_parameters_from_bytes(
+    bytes: &[u8],
+    checked: bool,
+) -> Result<ClaimParameters, ParameterError> {
+    let cursor = std::io::Cursor::new(bytes);
+    let reader = std::io::BufReader::new(cursor);
+
+    let params = Parameters::read(reader, checked).map_err(ParameterError::Deserialization)?;
+
+    Ok(ClaimParameters(params))
+}

crates/zair-sapling-proofs/src/prover/builder.rs

@@ -67,6 +67,7 @@ pub fn bytes_less_than(a: &[u8; 32], b: &[u8; 32]) -> bool {
 /// Returns an error if proof generation fails.
 #[allow(
     clippy::too_many_lines,
+    clippy::similar_names,
     reason = "End-to-end witness preparation and proving"
 )]
 pub fn generate_claim_proof(

crates/zair-sapling-proofs/src/prover/convenience.rs

@@ -5,7 +5,10 @@ mod builder;
 mod convenience;
 mod proving;
 
-pub use builder::{ParameterError, generate_parameters, load_parameters, save_parameters};
+pub use builder::{
+    ParameterError, generate_parameters, load_parameters, load_parameters_from_bytes,
+    save_parameters,
+};
 pub use convenience::generate_claim_proof;
 pub use proving::ClaimParameters;