Merge pull request #58 from moven0831/feat/mobile-app-migration

feat: mobile app migration

Author: 0xVikasRushi

wallet-unit-poc/README.md

@@ -112,7 +112,7 @@ cargo run --release -- benchmark
 
 ### Mobile Benchmarks
 
-For the reproduction of mobile benchmarks, please check this repo: https://github.com/moven0831/spartan2-hyrax-mopro
+For the reproduction of mobile benchmarks, please check the [OpenAC mobile app directory](/wallet-unit-poc/mobile/)
 
 #### Prepare Circuit (Mobile)
 
@@ -121,8 +121,8 @@ For the reproduction of mobile benchmarks, please check this repo: https://githu
 
 |    Device    | Setup (ms) | Prove (ms) | Reblind (ms) | Verify (ms) |
 |:------------:|:----------:|:----------:|:------------:|:-----------:|
-|  iPhone 17   |    3499    |    2987    |     856      |     151     |
-| Pixel 10 Pro |    9233    |    7318    |     1750     |     318     |
+|  iPhone 17   |    3254    |    2102    |     884      |     137     |
+| Pixel 10 Pro |    9282    |    5161    |     1732     |     318     |
 
 ### Show Circuit Timing
 
@@ -131,9 +131,5 @@ The Show circuit has constant performance regardless of JWT payload size.
 
 |    Device    | Setup (ms) | Prove (ms) | Reblind (ms) | Verify (ms) |
 |:------------:|:----------:|:----------:|:------------:|:-----------:|
-|  iPhone 17   |     47     |     99     |      30      |     13      |
-| Pixel 10 Pro |    122     |    340     |     125      |     61      |
-
-| iPhone 17 | Pixel 10 Pro |
-|-----------|--------------|
-| <img src="https://github.com/user-attachments/assets/45cabf07-66e8-446a-add6-bf036b2f40fa" width="300"> | <img src="https://github.com/user-attachments/assets/2d9499d4-e06e-4dc2-9a12-41fe9033245b" width="300"> |
+|  iPhone 17   |     43     |     85     |      30      |     13      |
+| Pixel 10 Pro |     99     |    308     |     130      |     65      |

wallet-unit-poc/ecdsa-spartan2/README.md

@@ -65,35 +65,6 @@ The Show circuit has constant performance regardless of JWT payload size.
 | Reblind | ~25       |
 | Verify  | ~9        |
 
-### Timing Measurements (Mobile)
-
-All timing measurements are in milliseconds (ms).
-
-**Test Device:** 
-- iOS: iPhone 17, A19 chip, 8GB RAM
-- Android: Pixel 10 Pro, Tensor G5, 16GB of RAM
-
-#### Prepare Circuit Timing
-
-- Payload Size: 1920 Bytes
-- Peak Memory Usage for Proving: 2.27 GiB
-
-|    Device    | Setup (ms) | Prove (ms) | Reblind (ms) | Verify (ms) |
-|:------------:|:----------:|:----------:|:------------:|:-----------:|
-|  iPhone 17   |    3499    |    2987    |     856      |     151     |
-| Pixel 10 Pro |    9233    |    7318    |     1750     |     318     |
-
-
-#### Show Circuit Timing
-
-The Show circuit has constant performance regardless of JWT payload size.
-- Peak Memory Usage for Proving: 1.96 GiB
-
-|    Device    | Setup (ms) | Prove (ms) | Reblind (ms) | Verify (ms) |
-|:------------:|:----------:|:----------:|:------------:|:-----------:|
-|  iPhone 17   |     47     |     99     |      30      |     13      |
-| Pixel 10 Pro |    122     |    340     |     125      |     61      |
-
 ### Size Measurements
 
 #### Prepare Circuit Sizes
@@ -128,5 +99,4 @@ To generate benchmark data for a specific payload size:
 ```sh
 # Run the complete benchmark pipeline
 cargo run --release -- benchmark
-
 ```

wallet-unit-poc/ecdsa-spartan2/build.rs

@@ -1,3 +1,41 @@
+use std::path::Path;
+
 fn main() {
-    witnesscalc_adapter::build_and_link("../circom/build/cpp/");
+    // Construct absolute path to circuits using CARGO_MANIFEST_DIR
+    // This ensures the path resolves correctly regardless of working directory
+    let manifest_dir = std::env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR not set");
+    let circuits_dir = std::path::PathBuf::from(&manifest_dir)
+        .parent() // Go up from ecdsa-spartan2/ to wallet-unit-poc/
+        .expect("Failed to get parent directory")
+        .join("circom/build/cpp");
+    let circuits_path = circuits_dir.to_str().unwrap();
+
+    // Check for pre-built witnesscalc cache from build_pod.sh
+    if let Ok(witnesscalc_cache) = std::env::var("WITNESSCALC_PREBUILD_CACHE") {
+        let out_dir = std::env::var("OUT_DIR").expect("OUT_DIR not set");
+        let target = std::env::var("TARGET").unwrap_or_default();
+
+        // Only apply for iOS targets
+        match target.as_str() {
+            "aarch64-apple-ios-sim" | "aarch64-apple-ios" | "x86_64-apple-ios" => {
+                let cache_src = Path::new(&witnesscalc_cache);
+                let target_witnesscalc = Path::new(&out_dir).join("witnesscalc");
+
+                // Symlink entire witnesscalc directory if cache exists and target doesn't
+                if cache_src.exists() && !target_witnesscalc.exists() {
+                    #[cfg(unix)]
+                    {
+                        println!(
+                            "cargo:warning=Using cached witnesscalc from: {}",
+                            cache_src.display()
+                        );
+                        std::os::unix::fs::symlink(&cache_src, &target_witnesscalc).ok();
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+
+    witnesscalc_adapter::build_and_link(circuits_path);
 }

wallet-unit-poc/ecdsa-spartan2/src/circuits/prepare_circuit.rs

@@ -1,4 +1,5 @@
 use crate::{
+    paths::PathConfig,
     prover::generate_prepare_witness,
     utils::{compute_prepare_shared_scalars, PrepareSharedScalars},
     Scalar, E,
@@ -7,36 +8,57 @@ use bellpepper_core::{num::AllocatedNum, ConstraintSystem, SynthesisError};
 use circom_scotia::{reader::load_r1cs, synthesize};
 use serde_json::Value;
 use spartan2::traits::circuit::SpartanCircuit;
-use std::{any::type_name, env::current_dir, fs::File, path::PathBuf};
+use std::{any::type_name, fs::File, path::PathBuf};
 
 witnesscalc_adapter::witness!(jwt);
 
 // jwt.circom
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone)]
 pub struct PrepareCircuit {
+    /// Path configuration for resolving file paths
+    path_config: PathConfig,
+    /// Optional override for input JSON path
     input_path: Option<PathBuf>,
 }
 
+impl Default for PrepareCircuit {
+    fn default() -> Self {
+        Self {
+            path_config: PathConfig::default(),
+            input_path: None,
+        }
+    }
+}
+
 impl PrepareCircuit {
-    pub fn new<P: Into<Option<PathBuf>>>(path: P) -> Self {
+    /// Create a new PrepareCircuit with PathConfig and optional input path override.
+    pub fn new(path_config: PathConfig, input_path: Option<PathBuf>) -> Self {
+        Self {
+            path_config,
+            input_path,
+        }
+    }
+
+    /// Create from just an input path (for backwards compatibility).
+    /// Uses development PathConfig.
+    pub fn with_input_path<P: Into<Option<PathBuf>>>(path: P) -> Self {
         Self {
+            path_config: PathConfig::development(),
             input_path: path.into(),
         }
     }
 
-    fn input_path_absolute(&self, cwd: &PathBuf) -> Option<PathBuf> {
-        self.input_path.as_ref().map(|p| {
-            if p.is_absolute() {
-                p.clone()
-            } else {
-                cwd.join(p)
-            }
-        })
+    /// Resolve the input JSON path using PathConfig.
+    fn resolve_input_json(&self) -> PathBuf {
+        self.input_path
+            .as_ref()
+            .map(|p| self.path_config.resolve(p))
+            .unwrap_or_else(|| self.path_config.input_json("jwt"))
     }
 
-    fn resolve_input_json(&self, cwd: &PathBuf) -> PathBuf {
-        self.input_path_absolute(cwd)
-            .unwrap_or_else(|| cwd.join("../circom/inputs/jwt/default.json"))
+    /// Get the R1CS file path.
+    fn r1cs_path(&self) -> PathBuf {
+        self.path_config.r1cs_path("jwt")
     }
 }
 
@@ -48,28 +70,27 @@ impl SpartanCircuit<E> for PrepareCircuit {
         _: &[AllocatedNum<Scalar>],
         _: Option<&[Scalar]>,
     ) -> Result<(), SynthesisError> {
-        let cwd = current_dir().unwrap();
-        let root = cwd.join("../circom");
-        let witness_dir = root.join("build/jwt/jwt_js");
-        let r1cs = witness_dir.join("jwt.r1cs");
+        let r1cs_path = self.r1cs_path();
 
         // Detect if we're in setup phase (ShapeCS) or prove phase (SatisfyingAssignment)
         // During setup, we only need constraint structure instead of actual witness values
         let cs_type = type_name::<CS>();
         let is_setup_phase = cs_type.contains("ShapeCS");
 
         if is_setup_phase {
-            let r1cs = load_r1cs(r1cs);
+            let r1cs = load_r1cs(&r1cs_path);
             // Pass None for witness during setup
             synthesize(cs, r1cs, None)?;
             return Ok(());
         }
 
         // Generate witness using the dedicated function
-        let input_path = self.input_path_absolute(&cwd);
-        let witness = generate_prepare_witness(input_path.as_ref().map(|p| p.as_path()))?;
+        let witness = generate_prepare_witness(
+            &self.path_config,
+            self.input_path.as_ref().map(|p| p.as_path()),
+        )?;
 
-        let r1cs = load_r1cs(r1cs);
+        let r1cs = load_r1cs(&r1cs_path);
         synthesize(cs, r1cs, Some(witness))?;
         Ok(())
     }
@@ -81,8 +102,7 @@ impl SpartanCircuit<E> for PrepareCircuit {
         &self,
         cs: &mut CS,
     ) -> Result<Vec<AllocatedNum<Scalar>>, SynthesisError> {
-        let cwd = current_dir().unwrap();
-        let json_path = self.resolve_input_json(&cwd);
+        let json_path = self.resolve_input_json();
 
         let json_file = File::open(&json_path).map_err(|_| SynthesisError::AssignmentMissing)?;
 

wallet-unit-poc/ecdsa-spartan2/src/circuits/show_circuit.rs

@@ -1,41 +1,64 @@
-use crate::{utils::*, Scalar, E};
+use crate::{paths::PathConfig, utils::*, Scalar, E};
 use bellpepper_core::{num::AllocatedNum, ConstraintSystem, SynthesisError};
 use circom_scotia::{reader::load_r1cs, synthesize};
 use serde_json::Value;
 use spartan2::traits::circuit::SpartanCircuit;
-use std::{any::type_name, env::current_dir, fs::File, path::PathBuf, time::Instant};
+use std::{any::type_name, fs::File, path::PathBuf, time::Instant};
 use tracing::info;
 
 witnesscalc_adapter::witness!(show);
 
 // show.circom
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone)]
 pub struct ShowCircuit {
+    /// Path configuration for resolving file paths
+    path_config: PathConfig,
+    /// Optional override for input JSON path
     input_path: Option<PathBuf>,
 }
 
+impl Default for ShowCircuit {
+    fn default() -> Self {
+        Self {
+            path_config: PathConfig::default(),
+            input_path: None,
+        }
+    }
+}
+
 impl ShowCircuit {
-    pub fn new<P: Into<Option<PathBuf>>>(path: P) -> Self {
+    /// Create a new ShowCircuit with PathConfig and optional input path override.
+    pub fn new(path_config: PathConfig, input_path: Option<PathBuf>) -> Self {
         Self {
+            path_config,
+            input_path,
+        }
+    }
+
+    /// Create from just an input path (for backwards compatibility).
+    /// Uses development PathConfig.
+    pub fn with_input_path<P: Into<Option<PathBuf>>>(path: P) -> Self {
+        Self {
+            path_config: PathConfig::development(),
             input_path: path.into(),
         }
     }
 
-    fn input_path_absolute(&self, cwd: &PathBuf) -> PathBuf {
+    /// Resolve the input JSON path using PathConfig.
+    fn resolve_input_json(&self) -> PathBuf {
         self.input_path
             .as_ref()
-            .map(|p| {
-                if p.is_absolute() {
-                    p.clone()
-                } else {
-                    cwd.join(p)
-                }
-            })
-            .unwrap_or_else(|| cwd.join("../circom/inputs/show/default.json"))
+            .map(|p| self.path_config.resolve(p))
+            .unwrap_or_else(|| self.path_config.input_json("show"))
+    }
+
+    /// Get the R1CS file path.
+    fn r1cs_path(&self) -> PathBuf {
+        self.path_config.r1cs_path("show")
     }
 
-    fn load_inputs(&self, cwd: &PathBuf) -> Result<Value, SynthesisError> {
-        let path = self.input_path_absolute(cwd);
+    fn load_inputs(&self) -> Result<Value, SynthesisError> {
+        let path = self.resolve_input_json();
         info!("Loading show inputs from {}", path.display());
         let file = File::open(&path).map_err(|_| SynthesisError::AssignmentMissing)?;
         serde_json::from_reader(file).map_err(|_| SynthesisError::AssignmentMissing)
@@ -50,11 +73,8 @@ impl SpartanCircuit<E> for ShowCircuit {
         _: &[AllocatedNum<Scalar>],
         _: Option<&[Scalar]>,
     ) -> Result<(), SynthesisError> {
-        let cwd = current_dir().unwrap();
-        let root = cwd.join("../circom");
-        let witness_dir = root.join("build/show/show_js");
-        let r1cs = witness_dir.join("show.r1cs");
-        let json_value = self.load_inputs(&cwd)?;
+        let r1cs_path = self.r1cs_path();
+        let json_value = self.load_inputs()?;
 
         // Parse inputs using declarative field definitions
         let inputs = parse_show_inputs(&json_value)?;
@@ -65,7 +85,7 @@ impl SpartanCircuit<E> for ShowCircuit {
         let is_setup_phase = cs_type.contains("ShapeCS");
 
         if is_setup_phase {
-            let r1cs = load_r1cs(r1cs);
+            let r1cs = load_r1cs(&r1cs_path);
             // Pass None for witness during setup
             synthesize(cs, r1cs, None)?;
             return Ok(());
@@ -78,15 +98,15 @@ impl SpartanCircuit<E> for ShowCircuit {
         let inputs_json = hashmap_to_json_string(&inputs)?;
 
         // Generate raw witness bytes
-        let witness_bytes = show_witness(&inputs_json)
-            .map_err(|_| SynthesisError::Unsatisfiable)?;
+        let witness_bytes =
+            show_witness(&inputs_json).map_err(|_| SynthesisError::Unsatisfiable)?;
 
         info!("witnesscalc time: {} ms", t0.elapsed().as_millis());
 
         // Parse witness bytes directly to Scalar
         let witness = parse_witness(&witness_bytes)?;
 
-        let r1cs = load_r1cs(r1cs);
+        let r1cs = load_r1cs(&r1cs_path);
         synthesize(cs, r1cs, Some(witness))?;
         Ok(())
     }
@@ -98,8 +118,7 @@ impl SpartanCircuit<E> for ShowCircuit {
         &self,
         cs: &mut CS,
     ) -> Result<Vec<AllocatedNum<Scalar>>, SynthesisError> {
-        let cwd = current_dir().unwrap();
-        let json_value = self.load_inputs(&cwd)?;
+        let json_value = self.load_inputs()?;
 
         let inputs = parse_show_inputs(&json_value)?;
         let keybinding_x_bigint = inputs.get("deviceKeyX").unwrap()[0].clone();

wallet-unit-poc/ecdsa-spartan2/src/lib.rs

@@ -12,21 +12,22 @@ pub type E = T256HyraxEngine;
 pub type Scalar = <E as Engine>::Scalar;
 
 pub mod circuits;
+pub mod paths;
 pub mod prover;
 pub mod setup;
 pub mod utils;
 
 // Re-export commonly used types and functions
 pub use circuits::{prepare_circuit::PrepareCircuit, show_circuit::ShowCircuit};
+pub use paths::PathConfig;
 pub use prover::{
     generate_prepare_witness, generate_shared_blinds, prove_circuit, prove_circuit_with_pk,
     reblind, reblind_with_loaded_data, run_circuit, verify_circuit,
     verify_circuit_with_loaded_data,
 };
 pub use setup::{
     load_instance, load_proof, load_proving_key, load_shared_blinds, load_verifying_key,
-    load_witness, save_keys, setup_circuit_keys, setup_circuit_keys_no_save, PREPARE_PROVING_KEY,
-    PREPARE_VERIFYING_KEY, SHOW_PROVING_KEY, SHOW_VERIFYING_KEY,
+    load_witness, save_keys, setup_circuit_keys, setup_circuit_keys_no_save,
 };
 pub use utils::{
     bigint_to_scalar, calculate_jwt_output_indices, convert_bigint_to_scalar, parse_jwt_inputs,