fix: Remove inlined circuit data bytes (#429)

* load artifacts from fs

* expose setup data in wasm

* expose setup data in ios

* add swift code

---------

Co-authored-by: devloper <3347622+devloper@users.noreply.github.com>
Co-authored-by: Tracy <devloper@users.noreply.github.com>

Author: piotr-roslaniec

client/src/errors.rs

@@ -99,6 +99,9 @@ pub enum ClientErrors {
   #[error(transparent)]
   Canceled(#[from] futures::channel::oneshot::Canceled),
 
+  #[error("Missing setup data")]
+  MissingSetupData,
+
   #[error("Manifest missing")]
   ManifestMissingError,
 

client/src/lib.rs

@@ -16,7 +16,12 @@ mod tls;
 pub mod tls_client_async2;
 use std::collections::HashMap;
 
-use proofs::{program::manifest::NIVCRom, proof::FoldingProof};
+pub use proofs::program::data::UninitializedSetup;
+use proofs::{
+  circuits::{construct_setup_data_from_fs, CIRCUIT_SIZE_512},
+  program::manifest::NIVCRom,
+  proof::FoldingProof,
+};
 use serde::{Deserialize, Serialize};
 pub use tlsn_core::proof::TlsProof;
 use tlsn_prover::tls::ProverConfig;
@@ -52,11 +57,12 @@ pub fn get_web_prover_circuits_version() -> String {
 pub async fn prover_inner(
   config: config::Config,
   proving_params: Option<Vec<u8>>,
+  setup_data: Option<UninitializedSetup>,
 ) -> Result<Proof, ClientErrors> {
   info!("GIT_HASH: {}", env!("GIT_HASH"));
   match config.mode {
     config::NotaryMode::TLSN => prover_inner_tlsn(config).await,
-    config::NotaryMode::Origo => prover_inner_origo(config, proving_params).await,
+    config::NotaryMode::Origo => prover_inner_origo(config, proving_params, setup_data).await,
     config::NotaryMode::TEE => prover_inner_tee(config).await,
     config::NotaryMode::Proxy => prover_inner_proxy(config).await,
   }
@@ -99,10 +105,22 @@ pub async fn prover_inner_tlsn(mut config: config::Config) -> Result<Proof, Clie
 pub async fn prover_inner_origo(
   config: config::Config,
   proving_params: Option<Vec<u8>>,
+  setup_data: Option<UninitializedSetup>,
 ) -> Result<Proof, ClientErrors> {
   let session_id = config.session_id.clone();
 
-  let mut proof = origo::proxy_and_sign_and_generate_proof(config.clone(), proving_params).await?;
+  let setup_data = if let Some(setup_data) = setup_data {
+    Ok(setup_data)
+  } else if !cfg!(target_os = "ios") && !cfg!(target_arch = "wasm32") {
+    // TODO: How do we decide which CIRCUIT_SIZE_* to use here?
+    construct_setup_data_from_fs::<CIRCUIT_SIZE_512>()
+      .map_err(|e| ClientErrors::Other(e.to_string()))
+  } else {
+    Err(ClientErrors::MissingSetupData)
+  }?;
+
+  let mut proof =
+    origo::proxy_and_sign_and_generate_proof(config.clone(), proving_params, setup_data).await?;
 
   let manifest = config.proving.manifest.clone().ok_or(ClientErrors::ManifestMissingError)?;
 

client/src/main.rs

@@ -33,8 +33,8 @@ async fn main() -> Result<(), ClientErrors> {
   let mut config: Config = serde_json::from_str(&config_json)?;
   config.set_session_id();
 
-  let proving_params = std::fs::read(proofs::circuits::PROVING_PARAMS_512).unwrap();
-  let proof = client::prover_inner(config, Some(proving_params)).await?;
+  let proving_params = std::fs::read(proofs::circuits::PROVING_PARAMS_512)?;
+  let proof = client::prover_inner(config, Some(proving_params), None).await?;
   let proof_json = serde_json::to_string_pretty(&proof)?;
   println!("Proving Successful: proof_len={:?}", proof_json.len());
   Ok(())

client/src/origo.rs

@@ -2,9 +2,8 @@
 use std::collections::HashMap;
 
 use proofs::{
-  circuits::construct_setup_data,
   program::{
-    data::{Offline, SetupParams},
+    data::{Offline, SetupParams, UninitializedSetup},
     manifest::{EncryptionInput, OrigoManifest, TLSEncryption},
   },
   F, G1, G2,
@@ -107,7 +106,7 @@ pub async fn verify(
   };
 
   let response = client.post(url).json(&verify_body).send().await?;
-  assert!(response.status() == hyper::StatusCode::OK, "response={:?}", response);
+  assert_eq!(response.status(), hyper::StatusCode::OK, "response={:?}", response);
   let verify_response = response.json::<SignedVerificationReply>().await?;
 
   debug!("\n{:?}\n\n", verify_response.clone());
@@ -119,6 +118,7 @@ pub async fn verify(
 pub(crate) async fn proxy_and_sign_and_generate_proof(
   config: config::Config,
   proving_params: Option<Vec<u8>>,
+  setup_data: UninitializedSetup,
 ) -> Result<OrigoProof, ClientErrors> {
   let session_id = config.session_id.clone();
 
@@ -138,7 +138,6 @@ pub(crate) async fn proxy_and_sign_and_generate_proof(
 
   let _sign_data = crate::origo::sign(config.clone(), session_id.clone(), sb).await;
 
-  debug!("generating program data!");
   let witness = origo_conn.to_witness_data();
 
   // decrypt TLS ciphertext for request and response and create NIVC inputs
@@ -151,6 +150,7 @@ pub(crate) async fn proxy_and_sign_and_generate_proof(
   let mut proof = generate_proof(
     &manifest.clone().into(),
     &proving_params.unwrap(),
+    &setup_data,
     &request_inputs,
     &response_inputs,
   )
@@ -170,28 +170,28 @@ pub(crate) async fn proxy_and_sign_and_generate_proof(
 pub(crate) async fn generate_proof(
   manifest: &OrigoManifest,
   proving_params: &[u8],
+  setup_data: &UninitializedSetup,
   request_inputs: &EncryptionInput,
   response_inputs: &EncryptionInput,
 ) -> Result<OrigoProof, ClientErrors> {
-  let setup_data = construct_setup_data::<{ proofs::circuits::CIRCUIT_SIZE_512 }>()?;
-  let program_data = SetupParams::<Offline> {
-    public_params: proving_params.to_vec(),
-    vk_digest_primary: F::<G1>::from(0), // These need to be right.
+  let setup_params = SetupParams::<Offline> {
+    public_params:       proving_params.to_vec(),
+    vk_digest_primary:   F::<G1>::from(0), // These need to be right.
     vk_digest_secondary: F::<G2>::from(0),
-    setup_data,
-    rom_data: HashMap::new(),
+    setup_data:          setup_data.clone(),
+    rom_data:            HashMap::new(),
   }
   .into_online()?;
 
-  let vk_digest_primary = program_data.vk_digest_primary;
-  let vk_digest_secondary = program_data.vk_digest_secondary;
+  let vk_digest_primary = setup_params.vk_digest_primary;
+  let vk_digest_secondary = setup_params.vk_digest_secondary;
   crate::proof::construct_program_data_and_proof::<{ proofs::circuits::CIRCUIT_SIZE_512 }>(
     manifest,
     request_inputs,
     response_inputs,
     (vk_digest_primary, vk_digest_secondary),
-    program_data.public_params,
-    program_data.setup_data,
+    setup_params.public_params,
+    setup_params.setup_data,
   )
   .await
 

client_ios/demo/demo/ContentView.swift

@@ -8,11 +8,48 @@
 import SwiftUI
 
 @_silgen_name("prover")
-func c_prover(_ config: UnsafePointer<Int8>?) -> UnsafePointer<Int8>?
+func c_prover(
+    _ config: UnsafePointer<Int8>?,
+    _ setupData: UnsafePointer<UninitializedSetupFFI>?
+) -> UnsafePointer<Int8>?
 
 @_silgen_name("setup_tracing")
 func c_setup_tracing()
 
+struct UninitializedSetupFFI {
+    let r1cs_types: UnsafePointer<UnsafePointer<UInt8>?>?
+    let r1cs_lengths: UnsafePointer<Int>?
+    let r1cs_count: Int
+    let witness_generator_types: UnsafePointer<UnsafePointer<UInt8>?>?
+    let witness_lengths: UnsafePointer<Int>?
+    let witness_count: Int
+}
+
+func createUninitializedSetupFFI(
+    r1cs: [Data],
+    witnessGenerators: [Data]
+) -> UninitializedSetupFFI {
+    let r1csPointers = r1cs.map { r1csData in
+        r1csData.withUnsafeBytes { $0.baseAddress!.assumingMemoryBound(to: UInt8.self) }
+    }
+
+    let witnessPointers = witnessGenerators.map { witnessData in
+        witnessData.withUnsafeBytes { $0.baseAddress!.assumingMemoryBound(to: UInt8.self) }
+    }
+
+    let r1csLengths = r1cs.map { $0.count }
+    let witnessLengths = witnessGenerators.map { $0.count }
+
+    return UninitializedSetupFFI(
+        r1cs_types: UnsafePointer(r1csPointers),
+        r1cs_lengths: UnsafePointer(r1csLengths),
+        r1cs_count: r1cs.count,
+        witness_generator_types: UnsafePointer(witnessPointers),
+        witness_lengths: UnsafePointer(witnessLengths),
+        witness_count: witnessGenerators.count
+    )
+}
+
 class CustomURLSessionDelegate: NSObject, URLSessionDelegate {
     func urlSession(_ session: URLSession, didReceive challenge: URLAuthenticationChallenge, completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void) {
         guard let serverTrust = challenge.protectionSpace.serverTrust else {
@@ -110,6 +147,11 @@ struct ContentView: View {
                        return
                    }
 
+                   guard let r1csData = r1csData else {
+                       print("Failed to fetch R1CS data")
+                       return
+                   }
+
                    if let data = r1cs_data {
                        print("data: \(data)")
                        let arrayString = data.map { String($0) }.joined(separator: ",")
@@ -175,9 +217,16 @@ struct ContentView: View {
                         }
                         """
 
+                       // Dummy witness generators (replace with real data later)
+                       let witnessGenerators: [Data] = [Data([0x01, 0x02]), Data([0x03, 0x04])]
+
+                       var setupData = createUninitializedSetupFFI(
+                           r1cs: r1cs_data,
+                       )
+
                        // NOTE: Witness generation happen in the library for ios
                        jsonString.withCString { (cString) in
-                           c_prover(cString)
+                           c_prover(cString, &setupData)
                        }
                        let timeElapsed = CFAbsoluteTimeGetCurrent() - start
                        print("Time elapsed: \(timeElapsed) seconds")

client_ios/src/lib.rs

@@ -4,7 +4,10 @@ use std::{
 };
 
 use client::config::Config;
-use proofs::circuits::PROVING_PARAMS_BYTES_512;
+use proofs::{
+  circuits::{construct_setup_data_from_fs, load_proving_params_512},
+  program::data::UninitializedSetup,
+};
 use tracing::debug;
 
 #[derive(serde::Serialize)]
@@ -27,10 +30,48 @@ pub unsafe extern "C" fn setup_tracing() {
   tracing::subscriber::set_global_default(collector).map_err(|e| panic!("{e:?}")).unwrap();
 }
 
+#[repr(C)]
+pub struct UninitializedSetupFFI {
+  r1cs_types:              *const *const u8,
+  r1cs_lengths:            *const usize,
+  r1cs_count:              usize,
+  witness_generator_types: *const *const u8,
+  witness_lengths:         *const usize,
+  witness_count:           usize,
+}
+
+impl UninitializedSetupFFI {
+  pub unsafe fn to_canonical(&self) -> UninitializedSetup {
+    // Deserialize `r1cs_types`
+    let r1cs_types = (0..self.r1cs_count)
+      .map(|i| {
+        let len = *self.r1cs_lengths.add(i);
+        let ptr = *self.r1cs_types.add(i);
+        std::slice::from_raw_parts(ptr, len).to_vec()
+      })
+      .collect::<Vec<Vec<u8>>>();
+
+    // Deserialize `witness_generator_types`
+    let witness_generator_types = (0..self.witness_count)
+      .map(|i| {
+        let len = *self.witness_lengths.add(i);
+        let ptr = *self.witness_generator_types.add(i);
+        std::slice::from_raw_parts(ptr, len).to_vec()
+      })
+      .collect::<Vec<Vec<u8>>>();
+
+    UninitializedSetup::from_raw_parts(r1cs_types, witness_generator_types)
+  }
+}
+
 #[no_mangle]
 // TODO: We should probably clarify this safety doc
 #[allow(clippy::missing_safety_doc)]
-pub unsafe extern "C" fn prover(config_json: *const c_char) -> *const c_char {
+pub unsafe extern "C" fn prover(
+  config_json: *const c_char,
+  // TODO: `setup_data` parameter handling is untested
+  setup_data: *const UninitializedSetupFFI,
+) -> *const c_char {
   let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
     let config_str = unsafe {
       assert!(!config_json.is_null());
@@ -43,8 +84,22 @@ pub unsafe extern "C" fn prover(config_json: *const c_char) -> *const c_char {
     let start = Instant::now();
     debug!("starting proving");
 
-    let proof =
-      rt.block_on(client::prover_inner(config, Some(PROVING_PARAMS_BYTES_512.to_vec()))).unwrap();
+    // TODO: Remove this after updating Swift client code
+    let setup_data = if setup_data.is_null() {
+      construct_setup_data_from_fs::<512>().unwrap()
+    } else {
+      let setup_data = unsafe { &*setup_data };
+      setup_data.to_canonical()
+    };
+
+    let proof = rt
+      .block_on(client::prover_inner(
+        config,
+        // TODO: Do I pass these here from `prover` call args or just make Some(...) in-place?
+        Some(load_proving_params_512().unwrap()),
+        Some(setup_data),
+      ))
+      .unwrap();
     debug!("done proving: {:?}", Instant::now() - start);
     serde_json::to_string_pretty(&proof).unwrap()
   }));