feat(openac-sdk): add TypeScript SDK for ZK credential proving

Introduces a new TypeScript/JavaScript SDK that provides a high-level API
for the zkID credential proving system:

- Core SDK classes: OpenAC, Prover, Verifier, Credential
- Input builders: buildJwtCircuitInputs, buildShowCircuitInputs
- NativeBackend wrapper for ecdsa-spartan2 Rust CLI
- WitnessCalculator for JS-based witness generation
- Comprehensive test suite using SDK public API with self-contained
  ES256 SD-JWT generation (no external JWT library dependencies)

e2e tests validate the actual integration surface users will consume,
generating test credentials programmatically and exercising the full
Prepare -> Show proving pipeline.

Author: 0xVikasRushi

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

@@ -21,9 +21,9 @@ pub mod utils;
 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,
+    generate_prepare_witness, generate_shared_blinds, prove_circuit, prove_circuit_in_memory,
+    prove_circuit_with_pk, reblind, reblind_in_memory, 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,

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

@@ -250,6 +250,109 @@ pub fn reblind_with_loaded_data<C: SpartanCircuit<E>>(
     }
 }
 
+/// Prove a circuit and return results in memory (no file I/O).
+/// This is the building block for the WASM `precompute()` API.
+pub fn prove_circuit_in_memory<C: SpartanCircuit<E> + Clone + std::fmt::Debug>(
+    circuit: C,
+    pk: &<R1CSSNARK<E> as R1CSSNARKTrait<E>>::ProverKey,
+) -> Result<
+    (
+        R1CSSNARK<E>,
+        spartan2::r1cs::SplitR1CSInstance<E>,
+        spartan2::r1cs::R1CSWitness<E>,
+    ),
+    SpartanError,
+> {
+    let t0 = Instant::now();
+    let mut prep_snark = R1CSSNARK::<E>::prep_prove(&pk, circuit.clone(), false)?;
+    let prep_ms = t0.elapsed().as_millis();
+    info!("ZK-Spartan prep_prove (in-memory): {} ms", prep_ms);
+
+    let t0 = Instant::now();
+    let mut transcript = <E as Engine>::TE::new(b"R1CSSNARK");
+    transcript.absorb(b"vk", &pk.vk_digest);
+
+    let public_values = SpartanCircuit::<E>::public_values(&circuit).map_err(|e| {
+        SpartanError::SynthesisError {
+            reason: format!("Circuit does not provide public IO: {e}"),
+        }
+    })?;
+
+    transcript.absorb(b"public_values", &public_values.as_slice());
+
+    let (instance, witness) = SatisfyingAssignment::r1cs_instance_and_witness(
+        &mut prep_snark.ps,
+        &pk.S,
+        &pk.ck,
+        &circuit,
+        false,
+        &mut transcript,
+    )
+    .map_err(|e| SpartanError::SynthesisError {
+        reason: format!("Instance/witness generation failed: {e}"),
+    })?;
+
+    let proof = R1CSSNARK::<E>::prove_inner(&pk, &instance, &witness, &mut transcript)?;
+    let prove_ms = t0.elapsed().as_millis();
+
+    info!(
+        "ZK-Spartan prove (in-memory): prep={} ms, prove={} ms, total={} ms",
+        prep_ms,
+        prove_ms,
+        prep_ms + prove_ms
+    );
+
+    Ok((proof, instance, witness))
+}
+
+/// Reblind a proof with shared randomness and return results in memory (no file I/O).
+/// This is the building block for the WASM `present()` API.
+pub fn reblind_in_memory<C: SpartanCircuit<E>>(
+    circuit: C,
+    pk: &<R1CSSNARK<E> as R1CSSNARKTrait<E>>::ProverKey,
+    instance: spartan2::r1cs::SplitR1CSInstance<E>,
+    witness: spartan2::r1cs::R1CSWitness<E>,
+    randomness: &[<E as Engine>::Scalar],
+) -> Result<
+    (
+        R1CSSNARK<E>,
+        spartan2::r1cs::SplitR1CSInstance<E>,
+        spartan2::r1cs::R1CSWitness<E>,
+    ),
+    SpartanError,
+> {
+    assert_eq!(randomness.len(), instance.num_shared_rows());
+
+    let mut reblind_transcript = <E as Engine>::TE::new(b"R1CSSNARK");
+    reblind_transcript.absorb(b"vk", &pk.vk_digest);
+
+    let public_values = SpartanCircuit::<E>::public_values(&circuit).map_err(|e| {
+        SpartanError::SynthesisError {
+            reason: format!("Circuit does not provide public IO: {e}"),
+        }
+    })?;
+
+    reblind_transcript.absorb(b"public_values", &public_values.as_slice());
+
+    let (new_instance, new_witness) = SatisfyingAssignment::reblind_r1cs_instance_and_witness(
+        &randomness,
+        instance,
+        witness,
+        &pk.ck,
+        &mut reblind_transcript,
+    )
+    .map_err(|e| SpartanError::SynthesisError {
+        reason: format!("Reblind failed: {e}"),
+    })?;
+
+    let proof =
+        R1CSSNARK::<E>::prove_inner(&pk, &new_instance, &new_witness, &mut reblind_transcript)?;
+
+    info!("ZK-Spartan reblind (in-memory): complete");
+
+    Ok((proof, new_instance, new_witness))
+}
+
 /// Only run the verification part using ZK-Spartan.
 /// Returns the public values embedded in the proof.
 pub fn verify_circuit(proof_path: impl AsRef<Path>, vk_path: impl AsRef<Path>) -> Vec<Scalar> {