1use serde::{Deserialize, Serialize};
7use sha3::{Digest, Sha3_512};
8use std::collections::HashMap;
9
10pub struct ZkProofSystem {
12 #[cfg(feature = "zk-culling")]
13 proving_key: ProvingKey,
14 #[cfg(feature = "zk-culling")]
15 verifying_key: VerifyingKey,
16 circuit_builder: CircuitBuilder,
17 pub(crate) proof_generator: ProofGenerator,
18 #[cfg(feature = "zk-culling")]
19 pub(crate) proof_verifier: ProofVerifier,
20 performance_monitor: ZkPerformanceMonitor,
21}
22
23#[derive(Debug, Clone, Serialize, Deserialize)]
25pub struct ProvingKey {
26 pub key_id: String,
27 pub circuit_id: String,
28 pub key_data: Vec<u8>,
29 pub parameters: CircuitParameters,
30}
31
32#[derive(Debug, Clone, Serialize, Deserialize)]
34pub struct VerifyingKey {
35 pub key_id: String,
36 pub circuit_id: String,
37 pub key_data: Vec<u8>,
38 pub parameters: CircuitParameters,
39}
40
41#[derive(Debug, Clone, Serialize, Deserialize)]
43pub struct CircuitParameters {
44 pub num_constraints: u32,
45 pub num_variables: u32,
46 pub num_inputs: u32,
47 pub security_level: u32,
48 pub curve: EllipticCurve,
49}
50
51#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
53pub enum EllipticCurve {
54 Bn254,
55 Bls12_381,
56 Pallas,
57 Vesta,
58}
59
60pub struct CircuitBuilder {
62 circuits: HashMap<String, ArithmeticCircuit>,
63 pub(crate) variable_counter: u32,
64 constraint_counter: u32,
65 pub(crate) current_circuit: Option<String>,
66}
67
68#[derive(Debug, Clone)]
70pub struct ArithmeticCircuit {
71 pub circuit_id: String,
72 pub variables: HashMap<String, CircuitVariable>,
73 pub constraints: Vec<CircuitConstraint>,
74 pub public_inputs: Vec<String>,
75 pub private_inputs: Vec<String>,
76 pub outputs: Vec<String>,
77}
78
79#[derive(Debug, Clone)]
81pub struct CircuitVariable {
82 pub variable_id: String,
83 pub variable_type: VariableType,
84 pub value: Option<FieldElement>,
85 pub is_public: bool,
86}
87
88#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
90pub enum VariableType {
91 Public,
92 Private,
93 Constant,
94 Intermediate,
95}
96
97#[derive(Debug, Clone)]
99pub struct CircuitConstraint {
100 pub constraint_id: u32,
101 pub left: CircuitExpression,
102 pub right: CircuitExpression,
103 pub output: CircuitExpression,
104}
105
106#[derive(Debug, Clone)]
108pub enum CircuitExpression {
109 Variable(String),
110 Constant(FieldElement),
111 Add(Box<CircuitExpression>, Box<CircuitExpression>),
112 Mul(Box<CircuitExpression>, Box<CircuitExpression>),
113 Neg(Box<CircuitExpression>),
114}
115
116#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
118pub struct FieldElement {
119 pub value: [u8; 32],
120}
121
122pub struct ProofGenerator {
124 proving_keys: HashMap<String, ProvingKey>,
125 pub(crate) witness_generator: WitnessGenerator,
126 pub(crate) proving_engine: ProvingEngine,
127}
128
129pub struct WitnessGenerator {
131 pub(crate) assignments: HashMap<String, HashMap<String, FieldElement>>,
132 pub(crate) random_values: HashMap<String, FieldElement>,
133}
134
135pub struct ProvingEngine {
137 pub engine_type: ProvingEngineType,
138 pub parameters: EngineParameters,
139}
140
141#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
143pub enum ProvingEngineType {
144 Halo2,
145 Bellman,
146 Groth16,
147 Plonk,
148}
149
150#[derive(Debug, Clone)]
152pub struct EngineParameters {
153 pub batch_size: u32,
154 pub parallel_proving: bool,
155 pub optimization_level: u32,
156}
157
158pub struct ProofVerifier {
160 verifying_keys: HashMap<String, VerifyingKey>,
161 pub(crate) verification_engine: VerificationEngine,
162}
163
164pub struct VerificationEngine {
166 pub engine_type: VerificationEngineType,
167 pub parameters: VerificationParameters,
168}
169
170#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
172pub enum VerificationEngineType {
173 Halo2,
174 Bellman,
175 Groth16,
176 Plonk,
177}
178
179#[derive(Debug, Clone)]
181pub struct VerificationParameters {
182 pub batch_verification: bool,
183 pub parallel_verification: bool,
184 pub cache_size: u32,
185}
186
187#[derive(Debug, Clone, Serialize, Deserialize)]
189pub struct ZkProof {
190 pub proof_id: String,
191 pub circuit_id: String,
192 pub proof_data: Vec<u8>,
193 pub public_inputs: Vec<FieldElement>,
194 pub verification_key_id: String,
195 pub metadata: ProofMetadata,
196}
197
198#[derive(Debug, Clone, Serialize, Deserialize)]
200pub struct ProofMetadata {
201 pub created_at: u64,
202 pub proving_time: u64,
203 pub circuit_size: u32,
204 pub security_level: u32,
205 pub prover_id: Option<String>,
206}
207
208#[derive(Debug, Clone, Serialize, Deserialize)]
210pub struct SemanticProof {
211 pub statement: MathematicalStatement,
212 pub proof: ZkProof,
213 pub context: ProofContext,
214 pub verification_result: Option<VerificationResult>,
215}
216
217#[derive(Debug, Clone, Serialize, Deserialize)]
219pub struct MathematicalStatement {
220 pub statement_id: String,
221 pub statement_type: StatementType,
222 pub expression: String,
223 pub variables: Vec<String>,
224 pub constraints: Vec<String>,
225}
226
227#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
229pub enum StatementType {
230 Equality,
231 Inequality,
232 Membership,
233 FunctionEvaluation,
234 Optimization,
235}
236
237#[derive(Debug, Clone, Serialize, Deserialize)]
239pub struct ProofContext {
240 pub domain: String,
241 pub purpose: String,
242 pub timestamp: u64,
243 pub nonce: [u8; 32],
244 pub additional_data: Vec<u8>,
245}
246
247#[derive(Debug, Clone, Serialize, Deserialize)]
249pub struct VerificationResult {
250 pub is_valid: bool,
251 pub verification_time: u64,
252 pub error_message: Option<String>,
253 pub proof_id: String,
254}
255
256pub struct ZkPerformanceMonitor {
258 pub(crate) circuit_metrics: HashMap<String, CircuitMetrics>,
259 proof_metrics: HashMap<String, ProofMetrics>,
260 global_metrics: ZkGlobalMetrics,
261}
262
263#[derive(Debug, Clone)]
265pub struct CircuitMetrics {
266 pub circuit_id: String,
267 pub num_constraints: u32,
268 pub proving_time: u64,
269 pub verification_time: u64,
270 pub memory_usage: u64,
271 pub success_rate: f64,
272}
273
274#[derive(Debug, Clone)]
276pub struct ProofMetrics {
277 pub proof_id: String,
278 pub circuit_id: String,
279 pub proving_time: u64,
280 pub proof_size: u64,
281 pub verification_time: u64,
282 pub is_valid: bool,
283}
284
285#[derive(Debug, Clone)]
287pub struct ZkGlobalMetrics {
288 pub total_proofs_generated: u64,
289 pub total_proofs_verified: u64,
290 pub average_proving_time: f64,
291 pub average_verification_time: f64,
292 pub total_circuits: u32,
293 pub active_provers: u32,
294 pub active_verifiers: u32,
295}
296
297impl ZkProofSystem {
298 pub fn new() -> Self {
302 Self {
303 #[cfg(feature = "zk-culling")]
304 proving_key: ProvingKey {
305 key_id: "default_pk".to_string(),
306 circuit_id: "default_circuit".to_string(),
307 key_data: vec![0u8; 1024],
308 parameters: CircuitParameters {
309 num_constraints: 1000,
310 num_variables: 1000,
311 num_inputs: 10,
312 security_level: 128,
313 curve: EllipticCurve::Bls12_381,
314 },
315 },
316 #[cfg(feature = "zk-culling")]
317 verifying_key: VerifyingKey {
318 key_id: "default_vk".to_string(),
319 circuit_id: "default_circuit".to_string(),
320 key_data: vec![0u8; 512],
321 parameters: CircuitParameters {
322 num_constraints: 1000,
323 num_variables: 1000,
324 num_inputs: 10,
325 security_level: 128,
326 curve: EllipticCurve::Bls12_381,
327 },
328 },
329 circuit_builder: CircuitBuilder::new(),
330 proof_generator: ProofGenerator::new(),
331 #[cfg(feature = "zk-culling")]
332 proof_verifier: ProofVerifier::new(),
333 performance_monitor: ZkPerformanceMonitor::new(),
334 }
335 }
336
337 pub fn create_circuit(&mut self, circuit_id: String) -> Result<(), ZkError> {
340 self.circuit_builder.create_circuit(circuit_id.clone())?;
341 Ok(())
342 }
343
344 pub fn add_variable(
346 &mut self,
347 circuit_id: &str,
348 variable_id: String,
349 variable_type: VariableType,
350 ) -> Result<(), ZkError> {
351 self.circuit_builder
352 .add_variable(circuit_id, variable_id, variable_type)
353 }
354
355 pub fn add_constraint(
357 &mut self,
358 circuit_id: &str,
359 left: CircuitExpression,
360 right: CircuitExpression,
361 output: CircuitExpression,
362 ) -> Result<(), ZkError> {
363 self.circuit_builder
364 .add_constraint(circuit_id, left, right, output)
365 }
366
367 pub fn generate_keys(&mut self, circuit_id: &str) -> Result<(), ZkError> {
369 #[cfg(feature = "zk-culling")]
370 {
371 use ark_snark::SNARK;
372 let circuit = self.circuit_builder.get_circuit(circuit_id)?;
373 let mut rng = zk_secure_rng();
374
375 let dynamic_circuit = arkworks_groth16::DynamicCircuit {
376 circuit: circuit.clone(),
377 witness: None,
378 };
379
380 let (pk, vk) =
381 ark_groth16::Groth16::<ark_bls12_381::Bls12_381>::circuit_specific_setup(
382 dynamic_circuit,
383 &mut rng,
384 )
385 .map_err(|e| ZkError::EngineError(e.to_string()))?;
386
387 use ark_serialize::CanonicalSerialize;
388 let mut pk_bytes = Vec::new();
389 pk.serialize_compressed(&mut pk_bytes)
390 .map_err(|e| ZkError::EngineError(e.to_string()))?;
391
392 let mut vk_bytes = Vec::new();
393 vk.serialize_compressed(&mut vk_bytes)
394 .map_err(|e| ZkError::EngineError(e.to_string()))?;
395
396 let proving_key = ProvingKey {
397 key_id: format!("pk_{}", circuit_id),
398 circuit_id: circuit_id.to_string(),
399 key_data: pk_bytes,
400 parameters: CircuitParameters {
401 num_constraints: circuit.constraints.len() as u32,
402 num_variables: circuit.variables.len() as u32,
403 num_inputs: circuit.public_inputs.len() as u32,
404 security_level: 128,
405 curve: EllipticCurve::Bls12_381,
406 },
407 };
408
409 let verifying_key = VerifyingKey {
410 key_id: format!("vk_{}", circuit_id),
411 circuit_id: circuit_id.to_string(),
412 key_data: vk_bytes,
413 parameters: CircuitParameters {
414 num_constraints: circuit.constraints.len() as u32,
415 num_variables: circuit.variables.len() as u32,
416 num_inputs: circuit.public_inputs.len() as u32,
417 security_level: 128,
418 curve: EllipticCurve::Bls12_381,
419 },
420 };
421
422 self.proving_key = proving_key.clone();
423 self.verifying_key = verifying_key.clone();
424
425 self.proof_generator
426 .store_proving_key(circuit_id.to_string(), proving_key);
427 self.proof_verifier
428 .store_verifying_key(circuit_id.to_string(), verifying_key);
429
430 Ok(())
431 }
432 #[cfg(not(feature = "zk-culling"))]
433 {
434 Err(ZkError::PendingImplementation(format!(
435 "Cannot generate keys for circuit '{circuit_id}': enable the zk-culling feature"
436 )))
437 }
438 }
439
440 pub fn generate_proof(
442 &mut self,
443 circuit_id: &str,
444 witness: HashMap<String, FieldElement>,
445 public_inputs: Vec<FieldElement>,
446 ) -> Result<ZkProof, ZkError> {
447 #[cfg(feature = "zk-culling")]
448 {
449 use ark_snark::SNARK;
450 let circuit = self.circuit_builder.get_circuit(circuit_id)?;
451 let mut rng = zk_secure_rng();
452
453 let dynamic_circuit = arkworks_groth16::DynamicCircuit {
454 circuit: circuit.clone(),
455 witness: Some(witness),
456 };
457
458 use ark_serialize::CanonicalDeserialize;
459 let pk_data = self
460 .proof_generator
461 .get_proving_key(circuit_id)
462 .map(|pk| pk.key_data.clone())
463 .unwrap_or_else(|_| self.proving_key.key_data.clone());
464 let pk = ark_groth16::ProvingKey::<ark_bls12_381::Bls12_381>::deserialize_compressed(
465 &pk_data[..],
466 )
467 .map_err(|e| ZkError::EngineError(e.to_string()))?;
468
469 let proof = ark_groth16::Groth16::<ark_bls12_381::Bls12_381>::prove(
470 &pk,
471 dynamic_circuit,
472 &mut rng,
473 )
474 .map_err(|e| ZkError::EngineError(e.to_string()))?;
475
476 use ark_serialize::CanonicalSerialize;
477 let mut proof_bytes = Vec::new();
478 proof
479 .serialize_compressed(&mut proof_bytes)
480 .map_err(|e| ZkError::EngineError(e.to_string()))?;
481
482 let metadata = ProofMetadata {
483 created_at: std::time::SystemTime::now()
484 .duration_since(std::time::UNIX_EPOCH)
485 .unwrap()
486 .as_secs(),
487 proving_time: 0,
488 circuit_size: circuit.constraints.len() as u32,
489 security_level: 128,
490 prover_id: None,
491 };
492
493 let zk_proof = ZkProof {
494 proof_id: format!(
495 "proof_{}",
496 std::time::SystemTime::now()
497 .duration_since(std::time::UNIX_EPOCH)
498 .unwrap()
499 .as_nanos()
500 ),
501 circuit_id: circuit_id.to_string(),
502 proof_data: proof_bytes,
503 public_inputs,
504 verification_key_id: self.verifying_key.key_id.clone(),
505 metadata,
506 };
507
508 Ok(zk_proof)
509 }
510 #[cfg(not(feature = "zk-culling"))]
511 {
512 Err(ZkError::PendingImplementation(format!(
513 "Cannot generate a proof for circuit '{circuit_id}' with {} witness value(s) and {} public input(s): enable the zk-culling feature",
514 witness.len(),
515 public_inputs.len()
516 )))
517 }
518 }
519
520 pub fn verify_proof(&mut self, proof: &ZkProof) -> Result<VerificationResult, ZkError> {
522 #[cfg(feature = "zk-culling")]
523 {
524 use ark_serialize::CanonicalDeserialize;
525 use ark_snark::SNARK;
526 let vk_data = self
527 .proof_verifier
528 .get_verifying_key(&proof.verification_key_id)
529 .map(|vk| vk.key_data.clone())
530 .unwrap_or_else(|_| self.verifying_key.key_data.clone());
531 let vk = ark_groth16::VerifyingKey::<ark_bls12_381::Bls12_381>::deserialize_compressed(
532 &vk_data[..],
533 )
534 .map_err(|e| ZkError::EngineError(e.to_string()))?;
535
536 let ark_proof = ark_groth16::Proof::<ark_bls12_381::Bls12_381>::deserialize_compressed(
537 &proof.proof_data[..],
538 )
539 .map_err(|e| ZkError::EngineError(e.to_string()))?;
540
541 let mut public_inputs = Vec::new();
542 for pi in &proof.public_inputs {
543 public_inputs.push(arkworks_groth16::field_element_to_fr(pi));
544 }
545
546 let start = std::time::Instant::now();
547 let is_valid = ark_groth16::Groth16::<ark_bls12_381::Bls12_381>::verify(
548 &vk,
549 &public_inputs,
550 &ark_proof,
551 )
552 .map_err(|e| ZkError::EngineError(e.to_string()))?;
553
554 Ok(VerificationResult {
555 is_valid,
556 verification_time: start.elapsed().as_millis() as u64,
557 error_message: None,
558 proof_id: proof.proof_id.clone(),
559 })
560 }
561 #[cfg(not(feature = "zk-culling"))]
562 {
563 Err(ZkError::PendingImplementation(format!(
564 "Cannot verify proof '{}': enable the zk-culling feature",
565 proof.proof_id
566 )))
567 }
568 }
569
570 pub fn generate_semantic_proof(
572 &mut self,
573 statement: MathematicalStatement,
574 witness: HashMap<String, FieldElement>,
575 ) -> Result<SemanticProof, ZkError> {
576 let circuit_id = format!("circuit_{}", statement.statement_id);
577 self.create_circuit(circuit_id.clone())?;
578 self.build_circuit_from_statement(&circuit_id, &statement)?;
579 self.generate_keys(&circuit_id)?;
580 let circuit = self.get_circuit_info(&circuit_id).unwrap();
587 let full_witness = self
588 .proof_generator
589 .witness_generator
590 .generate_witness(&circuit, witness)?;
591
592 let public_inputs = self.extract_public_inputs(&circuit_id, &full_witness);
593 let proof = self.generate_proof(&circuit_id, full_witness, public_inputs)?;
594
595 let context = ProofContext {
596 domain: "mathematical_proofs".to_string(),
597 purpose: "statement_verification".to_string(),
598 timestamp: std::time::SystemTime::now()
599 .duration_since(std::time::UNIX_EPOCH)
600 .unwrap()
601 .as_secs(),
602 nonce: self.generate_nonce(),
603 additional_data: vec![],
604 };
605
606 Ok(SemanticProof {
607 statement,
608 proof,
609 context,
610 verification_result: None,
611 })
612 }
613
614 pub fn verify_semantic_proof(
616 &mut self,
617 semantic_proof: &mut SemanticProof,
618 ) -> Result<(), ZkError> {
619 let result = self.verify_proof(&semantic_proof.proof)?;
620 if !result.is_valid {
621 return Err(ZkError::VerificationFailed(
622 "Proof verification failed".to_string(),
623 ));
624 }
625 semantic_proof.verification_result = Some(result);
626 Ok(())
627 }
628
629 #[cfg(feature = "zk-culling")]
643 pub fn prove_matrix_multiply(
644 &mut self,
645 m: usize,
646 k: usize,
647 n: usize,
648 a: &[i128],
649 b: &[i128],
650 ) -> Result<(bool, Vec<i128>), ZkError> {
651 use arkworks_groth16::i128_to_field_element;
652
653 if a.len() != m * k || b.len() != k * n {
654 return Err(ZkError::EngineError(
655 "matrix dimensions do not match the supplied data".to_string(),
656 ));
657 }
658
659 let mut c = vec![0i128; m * n];
661 for i in 0..m {
662 for j in 0..n {
663 let mut acc: i128 = 0;
664 for p in 0..k {
665 acc += a[i * k + p] * b[p * n + j];
666 }
667 c[i * n + j] = acc;
668 }
669 }
670
671 let circuit_id = format!("matmul_{}x{}x{}_{}", m, k, n, self.generate_proof_id());
672 self.create_circuit(circuit_id.clone())?;
673
674 let mut witness: HashMap<String, FieldElement> = HashMap::new();
675
676 for i in 0..m {
678 for j in 0..n {
679 let id = format!("c_{}_{}", i, j);
680 self.add_variable(&circuit_id, id.clone(), VariableType::Public)?;
681 witness.insert(id, i128_to_field_element(c[i * n + j]));
682 }
683 }
684 for i in 0..m {
686 for p in 0..k {
687 let id = format!("a_{}_{}", i, p);
688 self.add_variable(&circuit_id, id.clone(), VariableType::Private)?;
689 witness.insert(id, i128_to_field_element(a[i * k + p]));
690 }
691 }
692 for p in 0..k {
693 for j in 0..n {
694 let id = format!("b_{}_{}", p, j);
695 self.add_variable(&circuit_id, id.clone(), VariableType::Private)?;
696 witness.insert(id, i128_to_field_element(b[p * n + j]));
697 }
698 }
699
700 let one = CircuitExpression::Constant(i128_to_field_element(1));
704 for i in 0..m {
705 for j in 0..n {
706 let mut sum: Option<CircuitExpression> = None;
707 for p in 0..k {
708 let term = CircuitExpression::Mul(
709 Box::new(CircuitExpression::Variable(format!("a_{}_{}", i, p))),
710 Box::new(CircuitExpression::Variable(format!("b_{}_{}", p, j))),
711 );
712 sum = Some(match sum {
713 None => term,
714 Some(s) => CircuitExpression::Add(Box::new(s), Box::new(term)),
715 });
716 }
717 let sum =
718 sum.unwrap_or_else(|| CircuitExpression::Constant(i128_to_field_element(0)));
719 self.add_constraint(
720 &circuit_id,
721 sum,
722 one.clone(),
723 CircuitExpression::Variable(format!("c_{}_{}", i, j)),
724 )?;
725 }
726 }
727
728 self.generate_keys(&circuit_id)?;
730 let public_inputs = self.extract_public_inputs(&circuit_id, &witness);
731 let proof = self.generate_proof(&circuit_id, witness, public_inputs)?;
732 let result = self.verify_proof(&proof)?;
733 Ok((result.is_valid, c))
734 }
735
736 #[cfg(not(feature = "zk-culling"))]
739 pub fn prove_matrix_multiply(
740 &mut self,
741 _m: usize,
742 _k: usize,
743 _n: usize,
744 _a: &[i128],
745 _b: &[i128],
746 ) -> Result<(bool, Vec<i128>), ZkError> {
747 Err(ZkError::EngineError(
748 "zk-culling feature not enabled".to_string(),
749 ))
750 }
751
752 pub fn get_performance_stats(&self) -> ZkGlobalMetrics {
754 self.performance_monitor.get_global_stats()
755 }
756
757 pub fn list_circuits(&self) -> Vec<String> {
759 self.circuit_builder.list_circuits()
760 }
761
762 pub fn get_circuit_info(&self, circuit_id: &str) -> Option<ArithmeticCircuit> {
764 self.circuit_builder
765 .get_circuit(circuit_id)
766 .ok()
767 .and_then(|c| Some(c.clone()))
768 }
769
770 fn build_circuit_from_statement(
774 &mut self,
775 circuit_id: &str,
776 statement: &MathematicalStatement,
777 ) -> Result<(), ZkError> {
778 match statement.statement_type {
779 StatementType::Equality => self.build_equality_circuit(circuit_id, statement),
780 StatementType::Inequality => self.build_inequality_circuit(circuit_id, statement),
781 StatementType::Membership => self.build_membership_circuit(circuit_id, statement),
782 StatementType::FunctionEvaluation => self.build_function_circuit(circuit_id, statement),
783 StatementType::Optimization => self.build_optimization_circuit(circuit_id, statement),
784 }
785 }
786
787 fn build_equality_circuit(
789 &mut self,
790 circuit_id: &str,
791 statement: &MathematicalStatement,
792 ) -> Result<(), ZkError> {
793 for var in &statement.variables {
795 self.add_variable(circuit_id, var.clone(), VariableType::Private)?;
796 let mut b = [0u8; 32];
797 b[0] = 1;
798 self.add_constraint(
799 circuit_id,
800 CircuitExpression::Constant(FieldElement { value: b }),
801 CircuitExpression::Variable(var.clone()),
802 CircuitExpression::Variable(var.clone()),
803 )?;
804 }
805
806 self.add_variable(circuit_id, "left".to_string(), VariableType::Private)?;
807 self.add_variable(circuit_id, "right".to_string(), VariableType::Private)?;
808 self.add_variable(circuit_id, "result".to_string(), VariableType::Private)?;
809
810 let left_expr = CircuitExpression::Variable("left".to_string());
811 let right_expr = CircuitExpression::Variable("right".to_string());
812 let output_expr = CircuitExpression::Variable("result".to_string());
813 let mut one = [0u8; 32];
814 one[0] = 1;
815 let unit = CircuitExpression::Constant(FieldElement { value: one });
816
817 self.add_constraint(
819 circuit_id,
820 left_expr.clone(),
821 unit.clone(),
822 right_expr.clone(),
823 )?;
824 self.add_constraint(circuit_id, left_expr, right_expr, output_expr)?;
826
827 if !statement.expression.is_empty() {
828 for var in statement.variables.iter().take(3) {
829 self.add_variable(circuit_id, var.clone(), VariableType::Private)?;
830 }
831 }
832
833 Ok(())
834 }
835
836 fn build_inequality_circuit(
838 &mut self,
839 circuit_id: &str,
840 statement: &MathematicalStatement,
841 ) -> Result<(), ZkError> {
842 for var in &statement.variables {
843 self.add_variable(circuit_id, var.clone(), VariableType::Private)?;
844 let mut b = [0u8; 32];
845 b[0] = 1;
846 self.add_constraint(
847 circuit_id,
848 CircuitExpression::Constant(FieldElement { value: b }),
849 CircuitExpression::Variable(var.clone()),
850 CircuitExpression::Variable(var.clone()),
851 )?;
852 }
853 Ok(())
854 }
855
856 fn build_membership_circuit(
858 &mut self,
859 circuit_id: &str,
860 statement: &MathematicalStatement,
861 ) -> Result<(), ZkError> {
862 for var in &statement.variables {
864 self.add_variable(circuit_id, var.clone(), VariableType::Private)?;
865 let mut b = [0u8; 32];
866 b[0] = 1;
867 self.add_constraint(
868 circuit_id,
869 CircuitExpression::Constant(FieldElement { value: b }),
870 CircuitExpression::Variable(var.clone()),
871 CircuitExpression::Variable(var.clone()),
872 )?;
873 }
874 Ok(())
875 }
876
877 fn build_function_circuit(
879 &mut self,
880 circuit_id: &str,
881 statement: &MathematicalStatement,
882 ) -> Result<(), ZkError> {
883 for var in &statement.variables {
885 self.add_variable(circuit_id, var.clone(), VariableType::Private)?;
886 let mut b = [0u8; 32];
887 b[0] = 1;
888 self.add_constraint(
889 circuit_id,
890 CircuitExpression::Constant(FieldElement { value: b }),
891 CircuitExpression::Variable(var.clone()),
892 CircuitExpression::Variable(var.clone()),
893 )?;
894 }
895 Ok(())
896 }
897
898 fn build_optimization_circuit(
900 &mut self,
901 circuit_id: &str,
902 statement: &MathematicalStatement,
903 ) -> Result<(), ZkError> {
904 for var in &statement.variables {
906 self.add_variable(circuit_id, var.clone(), VariableType::Private)?;
907 let mut b = [0u8; 32];
908 b[0] = 1;
909 self.add_constraint(
910 circuit_id,
911 CircuitExpression::Constant(FieldElement { value: b }),
912 CircuitExpression::Variable(var.clone()),
913 CircuitExpression::Variable(var.clone()),
914 )?;
915 }
916 Ok(())
917 }
918
919 fn extract_public_inputs(
926 &self,
927 circuit_id: &str,
928 witness: &HashMap<String, FieldElement>,
929 ) -> Vec<FieldElement> {
930 match self.circuit_builder.get_circuit(circuit_id) {
931 Ok(circuit) => circuit
932 .public_inputs
933 .iter()
934 .map(|id| {
935 witness
936 .get(id)
937 .cloned()
938 .unwrap_or(FieldElement { value: [0u8; 32] })
939 })
940 .collect(),
941 Err(_) => Vec::new(),
942 }
943 }
944
945 #[cfg(feature = "zk-culling")]
947 fn generate_proof_id(&self) -> String {
948 use std::sync::atomic::{AtomicU64, Ordering};
949 static COUNTER: AtomicU64 = AtomicU64::new(1);
950 format!("proof_{}", COUNTER.fetch_add(1, Ordering::SeqCst))
951 }
952
953 pub(crate) fn generate_nonce(&self) -> [u8; 32] {
956 rand::random()
957 }
958}
959
960impl CircuitBuilder {
961 pub fn new() -> Self {
963 Self {
964 circuits: HashMap::new(),
965 variable_counter: 0,
966 constraint_counter: 0,
967 current_circuit: None,
968 }
969 }
970
971 pub fn create_circuit(&mut self, circuit_id: String) -> Result<(), ZkError> {
973 self.current_circuit = Some(circuit_id.clone());
974 self.circuits.insert(
975 circuit_id.clone(),
976 ArithmeticCircuit {
977 circuit_id,
978 variables: HashMap::new(),
979 constraints: Vec::new(),
980 public_inputs: Vec::new(),
981 private_inputs: Vec::new(),
982 outputs: Vec::new(),
983 },
984 );
985 Ok(())
986 }
987
988 pub fn add_variable(
990 &mut self,
991 circuit_id: &str,
992 variable_id: String,
993 variable_type: VariableType,
994 ) -> Result<(), ZkError> {
995 let circuit = self
996 .circuits
997 .get_mut(circuit_id)
998 .ok_or_else(|| ZkError::CircuitNotFound(circuit_id.to_string()))?;
999
1000 let is_public = matches!(variable_type, VariableType::Public);
1001
1002 let variable = CircuitVariable {
1003 variable_id: variable_id.clone(),
1004 variable_type: variable_type.clone(),
1005 value: None,
1006 is_public,
1007 };
1008
1009 circuit.variables.insert(variable_id.clone(), variable);
1010 self.variable_counter += 1;
1011
1012 if is_public {
1013 circuit.public_inputs.push(variable_id);
1014 } else {
1015 circuit.private_inputs.push(variable_id);
1016 }
1017
1018 Ok(())
1019 }
1020
1021 pub fn add_constraint(
1023 &mut self,
1024 circuit_id: &str,
1025 left: CircuitExpression,
1026 right: CircuitExpression,
1027 output: CircuitExpression,
1028 ) -> Result<(), ZkError> {
1029 let circuit = self
1030 .circuits
1031 .get_mut(circuit_id)
1032 .ok_or_else(|| ZkError::CircuitNotFound(circuit_id.to_string()))?;
1033
1034 let constraint = CircuitConstraint {
1035 constraint_id: self.constraint_counter,
1036 left,
1037 right,
1038 output,
1039 };
1040
1041 circuit.constraints.push(constraint);
1042 self.constraint_counter += 1;
1043
1044 Ok(())
1045 }
1046
1047 pub fn get_circuit(&self, circuit_id: &str) -> Result<&ArithmeticCircuit, ZkError> {
1049 self.circuits
1050 .get(circuit_id)
1051 .ok_or_else(|| ZkError::CircuitNotFound(circuit_id.to_string()))
1052 }
1053
1054 pub fn list_circuits(&self) -> Vec<String> {
1056 self.circuits.keys().cloned().collect()
1057 }
1058}
1059
1060impl ProofGenerator {
1061 pub fn new() -> Self {
1063 Self {
1064 proving_keys: HashMap::new(),
1065 witness_generator: WitnessGenerator::new(),
1066 proving_engine: ProvingEngine::new(),
1067 }
1068 }
1069
1070 pub fn generate_proving_key(&self, circuit: &ArithmeticCircuit) -> Result<ProvingKey, ZkError> {
1076 let mut hasher = Sha3_512::new();
1078 hasher.update(b"QUALAPK\x01");
1079 hasher.update(circuit.circuit_id.as_bytes());
1080 hasher.update(&(circuit.constraints.len() as u64).to_le_bytes());
1081 hasher.update(&(circuit.variables.len() as u64).to_le_bytes());
1082 hasher.update(&(circuit.public_inputs.len() as u64).to_le_bytes());
1083 for (i, constraint) in circuit.constraints.iter().enumerate() {
1085 hasher.update(&(constraint.constraint_id as u64).to_le_bytes());
1086 hasher.update(&(i as u64).to_le_bytes());
1087 }
1088 let seed = hasher.finalize();
1089
1090 let mut key_data = Vec::with_capacity(1024);
1092 let mut block = [0u8; 64];
1093 block.copy_from_slice(&seed);
1094 for round in 0u8..16 {
1095 let mut expand = Sha3_512::new();
1096 expand.update(&block);
1097 expand.update(&[round]);
1098 expand.update(b"QUALAPK-EXPAND");
1099 let out = expand.finalize();
1100 key_data.extend_from_slice(&out);
1101 block.copy_from_slice(&out);
1102 }
1103 key_data[..8].copy_from_slice(b"QUALAPK\x01");
1105
1106 Ok(ProvingKey {
1107 key_id: format!("pk_{}", circuit.circuit_id),
1108 circuit_id: circuit.circuit_id.clone(),
1109 key_data,
1110 parameters: CircuitParameters {
1111 num_constraints: circuit.constraints.len() as u32,
1112 num_variables: circuit.variables.len() as u32,
1113 num_inputs: circuit.public_inputs.len() as u32,
1114 security_level: self.proving_engine.parameters.optimization_level.max(128),
1115 curve: EllipticCurve::Bls12_381,
1116 },
1117 })
1118 }
1119
1120 pub fn store_proving_key(&mut self, circuit_id: String, proving_key: ProvingKey) {
1122 self.proving_keys.insert(circuit_id, proving_key);
1123 }
1124
1125 pub fn get_proving_key(&self, circuit_id: &str) -> Result<&ProvingKey, ZkError> {
1127 self.proving_keys
1128 .get(circuit_id)
1129 .ok_or_else(|| ZkError::KeyNotFound(circuit_id.to_string()))
1130 }
1131}
1132
1133impl ProofVerifier {
1134 pub fn new() -> Self {
1136 Self {
1137 verifying_keys: HashMap::new(),
1138 verification_engine: VerificationEngine::new(),
1139 }
1140 }
1141
1142 pub fn generate_verifying_key(
1149 &self,
1150 circuit: &ArithmeticCircuit,
1151 ) -> Result<VerifyingKey, ZkError> {
1152 let mut hasher = Sha3_512::new();
1154 hasher.update(b"QUALAVK\x01");
1155 hasher.update(circuit.circuit_id.as_bytes());
1156 hasher.update(&(circuit.constraints.len() as u64).to_le_bytes());
1157 hasher.update(&(circuit.variables.len() as u64).to_le_bytes());
1158 hasher.update(&(circuit.public_inputs.len() as u64).to_le_bytes());
1159 for (i, constraint) in circuit.constraints.iter().enumerate() {
1160 hasher.update(&(constraint.constraint_id as u64).to_le_bytes());
1161 hasher.update(&(i as u64).to_le_bytes());
1162 }
1163 let seed = hasher.finalize();
1164
1165 let mut xor_hasher = Sha3_512::new();
1167 xor_hasher.update(b"QUALAVK-XORFOLD");
1168 xor_hasher.update(&seed);
1169 let xor_seed = xor_hasher.finalize();
1170
1171 let mut key_data = Vec::with_capacity(512);
1173 let mut block = [0u8; 64];
1174 for i in 0..64 {
1175 block[i] = seed[i] ^ xor_seed[i];
1176 }
1177 for round in 0u8..8 {
1178 let mut expand = Sha3_512::new();
1179 expand.update(&block);
1180 expand.update(&[round]);
1181 expand.update(b"QUALAVK-EXPAND");
1182 let out = expand.finalize();
1183 key_data.extend_from_slice(&out);
1184 block.copy_from_slice(&out);
1185 }
1186 key_data[..8].copy_from_slice(b"QUALAVK\x01");
1188
1189 Ok(VerifyingKey {
1190 key_id: format!("vk_{}", circuit.circuit_id),
1191 circuit_id: circuit.circuit_id.clone(),
1192 key_data,
1193 parameters: CircuitParameters {
1194 num_constraints: circuit.constraints.len() as u32,
1195 num_variables: circuit.variables.len() as u32,
1196 num_inputs: circuit.public_inputs.len() as u32,
1197 security_level: self.verification_engine.parameters.cache_size.max(128),
1198 curve: EllipticCurve::Bls12_381,
1199 },
1200 })
1201 }
1202
1203 pub fn store_verifying_key(&mut self, circuit_id: String, verifying_key: VerifyingKey) {
1205 self.verifying_keys.insert(circuit_id, verifying_key);
1206 }
1207
1208 pub fn get_verifying_key(&self, key_id: &str) -> Result<&VerifyingKey, ZkError> {
1210 self.verifying_keys
1211 .get(key_id)
1212 .ok_or_else(|| ZkError::KeyNotFound(key_id.to_string()))
1213 }
1214}
1215
1216impl WitnessGenerator {
1217 pub fn new() -> Self {
1219 Self {
1220 assignments: HashMap::new(),
1221 random_values: HashMap::new(),
1222 }
1223 }
1224
1225 pub fn generate_witness(
1227 &mut self,
1228 circuit: &ArithmeticCircuit,
1229 partial_witness: HashMap<String, FieldElement>,
1230 ) -> Result<HashMap<String, FieldElement>, ZkError> {
1231 let mut full_witness = partial_witness.clone();
1232
1233 self.assignments
1234 .insert(circuit.circuit_id.clone(), partial_witness);
1235
1236 for (var_id, variable) in &circuit.variables {
1238 if !full_witness.contains_key(var_id)
1239 && variable.variable_type == VariableType::Intermediate
1240 {
1241 let random_value = FieldElement { value: [0u8; 32] }; self.random_values
1243 .insert(var_id.clone(), random_value.clone());
1244 full_witness.insert(var_id.clone(), random_value);
1245 }
1246 }
1247
1248 Ok(full_witness)
1249 }
1250}
1251
1252impl ProvingEngine {
1253 pub fn new() -> Self {
1255 Self {
1256 engine_type: ProvingEngineType::Halo2,
1257 parameters: EngineParameters {
1258 batch_size: 1,
1259 parallel_proving: false,
1260 optimization_level: 1,
1261 },
1262 }
1263 }
1264
1265 pub fn generate_proof(
1272 &self,
1273 proving_key: &ProvingKey,
1274 witness: &HashMap<String, FieldElement>,
1275 public_inputs: &[FieldElement],
1276 ) -> Result<Vec<u8>, ZkError> {
1277 let mut hasher = Sha3_512::new();
1279 hasher.update(b"QKZP"); hasher.update(proving_key.key_id.as_bytes());
1281 hasher.update(&proving_key.key_data);
1282 hasher.update(&self.parameters.batch_size.to_le_bytes());
1284 hasher.update(&(self.parameters.optimization_level as u64).to_le_bytes());
1285
1286 let mut witness_keys: Vec<_> = witness.keys().collect();
1288 witness_keys.sort();
1289 for key in &witness_keys {
1290 hasher.update(key.as_bytes());
1291 hasher.update(&witness[*key].value);
1292 }
1293
1294 for pi in public_inputs {
1296 hasher.update(&pi.value);
1297 }
1298
1299 let seed = hasher.finalize();
1300
1301 let mut proof_data = Vec::with_capacity(1024);
1303 let mut block = [0u8; 64];
1304 block.copy_from_slice(&seed);
1305 for round in 0u8..16 {
1306 let mut expand = Sha3_512::new();
1307 expand.update(&block);
1308 expand.update(&[round]);
1309 expand.update(b"QKZP-EXPAND");
1310 let out = expand.finalize();
1311 proof_data.extend_from_slice(&out);
1312 block.copy_from_slice(&out);
1313 }
1314
1315 proof_data[0] = 0x51; proof_data[1] = 0x4B; proof_data[2] = 0x5A; proof_data[3] = 0x50; Ok(proof_data)
1322 }
1323}
1324
1325impl VerificationEngine {
1326 pub fn new() -> Self {
1328 Self {
1329 engine_type: VerificationEngineType::Halo2,
1330 parameters: VerificationParameters {
1331 batch_verification: false,
1332 parallel_verification: false,
1333 cache_size: 100,
1334 },
1335 }
1336 }
1337
1338 pub fn verify_proof(
1344 &self,
1345 verifying_key: &VerifyingKey,
1346 proof: &[u8],
1347 public_inputs: &[FieldElement],
1348 ) -> Result<bool, ZkError> {
1349 if proof.len() < 32 {
1350 return Ok(false);
1351 }
1352 if public_inputs.is_empty() {
1353 return Ok(false);
1354 }
1355 if verifying_key.key_data.is_empty() {
1356 return Ok(false);
1357 }
1358 let has_nonzero = proof.iter().any(|&b| b != 0);
1360 Ok(has_nonzero)
1361 }
1362}
1363
1364impl ZkPerformanceMonitor {
1365 pub fn new() -> Self {
1367 Self {
1368 circuit_metrics: HashMap::new(),
1369 proof_metrics: HashMap::new(),
1370 global_metrics: ZkGlobalMetrics {
1371 total_proofs_generated: 0,
1372 total_proofs_verified: 0,
1373 average_proving_time: 0.0,
1374 average_verification_time: 0.0,
1375 total_circuits: 0,
1376 active_provers: 0,
1377 active_verifiers: 0,
1378 },
1379 }
1380 }
1381
1382 pub fn update_proof_metrics(&mut self, proof: &ZkProof, is_valid: bool) {
1384 let metrics = ProofMetrics {
1385 proof_id: proof.proof_id.clone(),
1386 circuit_id: proof.circuit_id.clone(),
1387 proving_time: proof.metadata.proving_time,
1388 proof_size: proof.proof_data.len() as u64,
1389 verification_time: 1000, is_valid,
1391 };
1392
1393 self.proof_metrics.insert(proof.proof_id.clone(), metrics);
1394
1395 let circuit_metrics = self
1396 .circuit_metrics
1397 .entry(proof.circuit_id.clone())
1398 .or_insert_with(|| CircuitMetrics {
1399 circuit_id: proof.circuit_id.clone(),
1400 num_constraints: proof.metadata.circuit_size,
1401 proving_time: 0,
1402 verification_time: 0,
1403 memory_usage: 0,
1404 success_rate: 0.0,
1405 });
1406 circuit_metrics.proving_time += proof.metadata.proving_time;
1407 if is_valid {
1408 circuit_metrics.success_rate = 1.0;
1409 }
1410
1411 self.global_metrics.total_proofs_generated += 1;
1413 self.global_metrics.total_proofs_verified += 1;
1414 }
1415
1416 pub fn get_global_stats(&self) -> ZkGlobalMetrics {
1418 self.global_metrics.clone()
1419 }
1420}
1421
1422#[derive(Debug, Clone)]
1424pub enum ZkError {
1425 PendingImplementation(String),
1426 CircuitNotFound(String),
1427 KeyNotFound(String),
1428 ProofGenerationFailed(String),
1429 VerificationFailed(String),
1430 InvalidCircuit(String),
1431 InvalidWitness(String),
1432 EngineError(String),
1433}
1434
1435impl std::fmt::Display for ZkError {
1436 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1437 match self {
1438 ZkError::PendingImplementation(msg) => {
1439 write!(f, "Pending implementation (MCP Backlog): {}", msg)
1440 }
1441 ZkError::CircuitNotFound(msg) => write!(f, "Circuit not found: {}", msg),
1442 ZkError::KeyNotFound(msg) => write!(f, "Key not found: {}", msg),
1443 ZkError::ProofGenerationFailed(msg) => write!(f, "Proof generation failed: {}", msg),
1444 ZkError::VerificationFailed(msg) => write!(f, "Verification failed: {}", msg),
1445 ZkError::InvalidCircuit(msg) => write!(f, "Invalid circuit: {}", msg),
1446 ZkError::InvalidWitness(msg) => write!(f, "Invalid witness: {}", msg),
1447 ZkError::EngineError(msg) => write!(f, "Engine error: {}", msg),
1448 }
1449 }
1450}
1451
1452impl std::error::Error for ZkError {}
1453
1454#[cfg(test)]
1455mod tests {
1456 use super::*;
1457
1458 #[test]
1459 fn test_zk_proof_system_creation() {
1460 let zk_system = ZkProofSystem::new();
1461 assert_eq!(zk_system.list_circuits().len(), 0);
1462 }
1463
1464 #[test]
1465 fn test_circuit_creation() {
1466 let mut zk_system = ZkProofSystem::new();
1467
1468 zk_system
1469 .create_circuit("test_circuit".to_string())
1470 .unwrap();
1471 assert!(zk_system
1472 .list_circuits()
1473 .contains(&"test_circuit".to_string()));
1474 }
1475
1476 #[test]
1477 fn test_variable_addition() {
1478 let mut zk_system = ZkProofSystem::new();
1479
1480 zk_system
1481 .create_circuit("test_circuit".to_string())
1482 .unwrap();
1483 zk_system
1484 .add_variable("test_circuit", "var1".to_string(), VariableType::Public)
1485 .unwrap();
1486
1487 let circuit = zk_system.get_circuit_info("test_circuit").unwrap();
1488 assert!(circuit.variables.contains_key("var1"));
1489 assert!(circuit.public_inputs.contains(&"var1".to_string()));
1490 }
1491
1492 #[test]
1493 fn test_proof_generation_verification() {
1494 let mut zk_system = ZkProofSystem::new();
1495
1496 zk_system
1497 .create_circuit("test_circuit".to_string())
1498 .unwrap();
1499 zk_system
1500 .add_variable("test_circuit", "result".to_string(), VariableType::Public)
1501 .unwrap();
1502 zk_system
1503 .add_variable("test_circuit", "x".to_string(), VariableType::Private)
1504 .unwrap();
1505 zk_system
1506 .add_variable("test_circuit", "y".to_string(), VariableType::Private)
1507 .unwrap();
1508
1509 let left_expr = CircuitExpression::Variable("x".to_string());
1510 let right_expr = CircuitExpression::Variable("y".to_string());
1511 let output_expr = CircuitExpression::Variable("result".to_string());
1512
1513 zk_system
1514 .add_constraint("test_circuit", left_expr, right_expr, output_expr)
1515 .unwrap();
1516
1517 zk_system.generate_keys("test_circuit").unwrap();
1519
1520 let mut witness = HashMap::new();
1522 let mut x_val = [0u8; 32];
1523 x_val[0] = 3;
1524 let mut y_val = [0u8; 32];
1525 y_val[0] = 4;
1526 let mut res_val = [0u8; 32];
1527 res_val[0] = 12;
1528
1529 witness.insert("x".to_string(), FieldElement { value: x_val });
1530 witness.insert("y".to_string(), FieldElement { value: y_val });
1531 witness.insert("result".to_string(), FieldElement { value: res_val });
1532
1533 let public_inputs = vec![FieldElement { value: res_val }];
1534
1535 let proof = zk_system
1536 .generate_proof("test_circuit", witness, public_inputs)
1537 .unwrap();
1538
1539 let result = zk_system.verify_proof(&proof).unwrap();
1541 assert!(result.is_valid);
1542 }
1543
1544 #[test]
1545 fn test_proof_rejects_falsified_public_input() {
1546 let mut zk_system = ZkProofSystem::new();
1550 zk_system.create_circuit("snd_circuit".to_string()).unwrap();
1551 zk_system
1552 .add_variable("snd_circuit", "result".to_string(), VariableType::Public)
1553 .unwrap();
1554 zk_system
1555 .add_variable("snd_circuit", "x".to_string(), VariableType::Private)
1556 .unwrap();
1557 zk_system
1558 .add_variable("snd_circuit", "y".to_string(), VariableType::Private)
1559 .unwrap();
1560 zk_system
1561 .add_constraint(
1562 "snd_circuit",
1563 CircuitExpression::Variable("x".to_string()),
1564 CircuitExpression::Variable("y".to_string()),
1565 CircuitExpression::Variable("result".to_string()),
1566 )
1567 .unwrap();
1568 zk_system.generate_keys("snd_circuit").unwrap();
1569
1570 let mut witness = HashMap::new();
1571 let mut x_val = [0u8; 32];
1572 x_val[0] = 3;
1573 let mut y_val = [0u8; 32];
1574 y_val[0] = 4;
1575 let mut res_val = [0u8; 32];
1576 res_val[0] = 12;
1577 witness.insert("x".to_string(), FieldElement { value: x_val });
1578 witness.insert("y".to_string(), FieldElement { value: y_val });
1579 witness.insert("result".to_string(), FieldElement { value: res_val });
1580
1581 let public_inputs = vec![FieldElement { value: res_val }];
1582 let mut proof = zk_system
1583 .generate_proof("snd_circuit", witness, public_inputs)
1584 .unwrap();
1585
1586 let mut wrong = [0u8; 32];
1588 wrong[0] = 13;
1589 proof.public_inputs = vec![FieldElement { value: wrong }];
1590
1591 let result = zk_system.verify_proof(&proof).unwrap();
1592 assert!(
1593 !result.is_valid,
1594 "a Groth16 proof must NOT verify against a falsified public input"
1595 );
1596 }
1597
1598 #[test]
1599 fn test_matrix_multiply_zk_roundtrip() {
1600 let mut zk = ZkProofSystem::new();
1602 let (ok, c) = zk
1604 .prove_matrix_multiply(2, 2, 2, &[1, 2, 3, 4], &[5, 6, 7, 8])
1605 .unwrap();
1606 assert!(ok, "proof of the correct product must verify");
1607 assert_eq!(c, vec![19, 22, 43, 50]);
1608 }
1609
1610 #[test]
1611 #[cfg(feature = "zk-culling")]
1612 fn test_matrix_multiply_circuit_rejects_false_product() {
1613 use arkworks_groth16::i128_to_field_element;
1617 let mut zk = ZkProofSystem::new();
1618 zk.create_circuit("dot".to_string()).unwrap();
1619 zk.add_variable("dot", "c".to_string(), VariableType::Public)
1620 .unwrap();
1621 zk.add_variable("dot", "a0".to_string(), VariableType::Private)
1622 .unwrap();
1623 zk.add_variable("dot", "a1".to_string(), VariableType::Private)
1624 .unwrap();
1625 zk.add_variable("dot", "b0".to_string(), VariableType::Private)
1626 .unwrap();
1627 zk.add_variable("dot", "b1".to_string(), VariableType::Private)
1628 .unwrap();
1629 let sum = CircuitExpression::Add(
1631 Box::new(CircuitExpression::Mul(
1632 Box::new(CircuitExpression::Variable("a0".to_string())),
1633 Box::new(CircuitExpression::Variable("b0".to_string())),
1634 )),
1635 Box::new(CircuitExpression::Mul(
1636 Box::new(CircuitExpression::Variable("a1".to_string())),
1637 Box::new(CircuitExpression::Variable("b1".to_string())),
1638 )),
1639 );
1640 zk.add_constraint(
1641 "dot",
1642 sum,
1643 CircuitExpression::Constant(i128_to_field_element(1)),
1644 CircuitExpression::Variable("c".to_string()),
1645 )
1646 .unwrap();
1647 zk.generate_keys("dot").unwrap();
1648
1649 let mut witness = HashMap::new();
1651 witness.insert("a0".to_string(), i128_to_field_element(3));
1652 witness.insert("a1".to_string(), i128_to_field_element(4));
1653 witness.insert("b0".to_string(), i128_to_field_element(5));
1654 witness.insert("b1".to_string(), i128_to_field_element(6));
1655 witness.insert("c".to_string(), i128_to_field_element(39));
1656
1657 let mut proof = zk
1658 .generate_proof("dot", witness, vec![i128_to_field_element(39)])
1659 .unwrap();
1660 assert!(
1661 zk.verify_proof(&proof).unwrap().is_valid,
1662 "honest dot product must verify"
1663 );
1664
1665 proof.public_inputs = vec![i128_to_field_element(40)];
1667 assert!(
1668 !zk.verify_proof(&proof).unwrap().is_valid,
1669 "a falsified dot-product result must NOT verify"
1670 );
1671 }
1672}
1673
1674#[cfg(feature = "zk-culling")]
1679pub(crate) fn zk_secure_rng() -> ark_std::rand::rngs::StdRng {
1680 use ark_std::rand::SeedableRng;
1681 let mut seed = [0u8; 32];
1682 getrandom::fill(&mut seed).expect("OS entropy for zk RNG seed");
1683 ark_std::rand::rngs::StdRng::from_seed(seed)
1684}
1685
1686#[cfg(feature = "zk-culling")]
1687pub mod arkworks_groth16 {
1688 use ark_bls12_381::{Bls12_381, Fr};
1689 use ark_ff::Field;
1690 use ark_groth16::{Groth16, Proof, ProvingKey, VerifyingKey};
1691 use ark_relations::gr1cs::{ConstraintSynthesizer, ConstraintSystemRef, SynthesisError};
1692 use ark_snark::SNARK;
1693
1694 #[derive(Clone)]
1697 pub struct MultiplierCircuit<F: Field> {
1698 pub a: Option<F>,
1699 pub b: Option<F>,
1700 }
1701
1702 impl<F: Field> ConstraintSynthesizer<F> for MultiplierCircuit<F> {
1703 fn generate_constraints(self, cs: ConstraintSystemRef<F>) -> Result<(), SynthesisError> {
1704 let a = cs.new_witness_variable(|| self.a.ok_or(SynthesisError::AssignmentMissing))?;
1705 let b = cs.new_witness_variable(|| self.b.ok_or(SynthesisError::AssignmentMissing))?;
1706 let c = cs.new_input_variable(|| {
1707 let mut a_val = self.a.ok_or(SynthesisError::AssignmentMissing)?;
1708 let b_val = self.b.ok_or(SynthesisError::AssignmentMissing)?;
1709 a_val.mul_assign(&b_val);
1710 Ok(a_val)
1711 })?;
1712
1713 cs.enforce_r1cs_constraint(|| a.into(), || b.into(), || c.into())?;
1714 Ok(())
1715 }
1716 }
1717
1718 use crate::zk_proofs::{ArithmeticCircuit, CircuitExpression, FieldElement, VariableType};
1719 use ark_ff::PrimeField;
1720 use ark_relations::gr1cs::{LinearCombination, Variable};
1721 use std::collections::HashMap;
1722
1723 pub fn field_element_to_fr(fe: &FieldElement) -> Fr {
1726 Fr::from_le_bytes_mod_order(&fe.value)
1727 }
1728
1729 pub fn i128_to_field_element(n: i128) -> FieldElement {
1734 use ark_ff::BigInteger;
1735 let mut fr = Fr::from(n.unsigned_abs());
1736 if n < 0 {
1737 fr = -fr;
1738 }
1739 let bytes = fr.into_bigint().to_bytes_le();
1740 let mut value = [0u8; 32];
1741 let len = bytes.len().min(32);
1742 value[..len].copy_from_slice(&bytes[..len]);
1743 FieldElement { value }
1744 }
1745
1746 #[derive(Clone)]
1747 pub struct DynamicCircuit {
1748 pub circuit: ArithmeticCircuit,
1749 pub witness: Option<HashMap<String, FieldElement>>,
1750 }
1751
1752 impl ConstraintSynthesizer<Fr> for DynamicCircuit {
1753 fn generate_constraints(self, cs: ConstraintSystemRef<Fr>) -> Result<(), SynthesisError> {
1754 let mut var_map: HashMap<String, Variable> = HashMap::new();
1755
1756 for var_id in &self.circuit.public_inputs {
1757 if let Some(_var) = self.circuit.variables.get(var_id) {
1758 let val = self
1759 .witness
1760 .as_ref()
1761 .and_then(|w| w.get(var_id).map(field_element_to_fr));
1762 let r1cs_var =
1763 cs.new_input_variable(|| val.ok_or(SynthesisError::AssignmentMissing))?;
1764 var_map.insert(var_id.clone(), r1cs_var);
1765 }
1766 }
1767
1768 for var_id in &self.circuit.private_inputs {
1769 if let Some(var) = self.circuit.variables.get(var_id) {
1770 let val = self
1771 .witness
1772 .as_ref()
1773 .and_then(|w| w.get(var_id).map(field_element_to_fr));
1774 let r1cs_var = if var.variable_type == VariableType::Constant {
1775 cs.new_witness_variable(|| val.ok_or(SynthesisError::AssignmentMissing))?
1776 } else {
1777 cs.new_witness_variable(|| val.ok_or(SynthesisError::AssignmentMissing))?
1778 };
1779 var_map.insert(var_id.clone(), r1cs_var);
1780 }
1781 }
1782
1783 for constraint in &self.circuit.constraints {
1784 let (left_lc, _) =
1785 evaluate_expression(cs.clone(), &constraint.left, &var_map, &self.witness)?;
1786 let (right_lc, _) =
1787 evaluate_expression(cs.clone(), &constraint.right, &var_map, &self.witness)?;
1788 let (out_lc, _) =
1789 evaluate_expression(cs.clone(), &constraint.output, &var_map, &self.witness)?;
1790
1791 cs.enforce_r1cs_constraint(|| left_lc, || right_lc, || out_lc)?;
1792 }
1793
1794 Ok(())
1795 }
1796 }
1797
1798 fn evaluate_expression(
1799 cs: ConstraintSystemRef<Fr>,
1800 expr: &CircuitExpression,
1801 var_map: &HashMap<String, Variable>,
1802 witness: &Option<HashMap<String, FieldElement>>,
1803 ) -> Result<(LinearCombination<Fr>, Option<Fr>), SynthesisError> {
1804 match expr {
1805 CircuitExpression::Variable(id) => {
1806 let var = var_map.get(id).ok_or(SynthesisError::AssignmentMissing)?;
1807 let val = witness
1808 .as_ref()
1809 .and_then(|w| w.get(id).map(field_element_to_fr));
1810 Ok((LinearCombination::from(*var), val))
1811 }
1812 CircuitExpression::Constant(c) => {
1813 let val = field_element_to_fr(c);
1814 Ok((LinearCombination::from((val, Variable::One)), Some(val)))
1815 }
1816 CircuitExpression::Add(a, b) => {
1817 let (lc_a, val_a) = evaluate_expression(cs.clone(), a, var_map, witness)?;
1818 let (lc_b, val_b) = evaluate_expression(cs.clone(), b, var_map, witness)?;
1819 let val = match (val_a, val_b) {
1820 (Some(av), Some(bv)) => Some(av + bv),
1821 _ => None,
1822 };
1823 Ok((lc_a + lc_b, val))
1824 }
1825 CircuitExpression::Neg(a) => {
1826 let (lc_a, val_a) = evaluate_expression(cs.clone(), a, var_map, witness)?;
1827 let val = val_a.map(|v| -v);
1828 Ok((-lc_a, val))
1829 }
1830 CircuitExpression::Mul(a, b) => {
1831 let (lc_a, val_a) = evaluate_expression(cs.clone(), a, var_map, witness)?;
1832 let (lc_b, val_b) = evaluate_expression(cs.clone(), b, var_map, witness)?;
1833
1834 let val = match (val_a, val_b) {
1835 (Some(av), Some(bv)) => Some(av * bv),
1836 _ => None,
1837 };
1838
1839 let out_var =
1840 cs.new_witness_variable(|| val.ok_or(SynthesisError::AssignmentMissing))?;
1841 cs.enforce_r1cs_constraint(|| lc_a, || lc_b, || out_var.into())?;
1842
1843 Ok((LinearCombination::from(out_var), val))
1844 }
1845 }
1846 }
1847
1848 pub struct TrueZkSystem {
1849 pub pk: ProvingKey<Bls12_381>,
1850 pub vk: VerifyingKey<Bls12_381>,
1851 }
1852
1853 impl TrueZkSystem {
1854 pub fn setup() -> Result<Self, SynthesisError> {
1857 let mut rng = super::zk_secure_rng();
1858 let circuit = MultiplierCircuit::<Fr> { a: None, b: None };
1859 let (pk, vk) = Groth16::<Bls12_381>::circuit_specific_setup(circuit, &mut rng).unwrap();
1860 Ok(Self { pk, vk })
1861 }
1862
1863 pub fn generate_proof(&self, a: Fr, b: Fr) -> Result<Proof<Bls12_381>, SynthesisError> {
1865 let mut rng = super::zk_secure_rng();
1866 let circuit = MultiplierCircuit {
1867 a: Some(a),
1868 b: Some(b),
1869 };
1870 Groth16::<Bls12_381>::prove(&self.pk, circuit, &mut rng)
1871 }
1872
1873 pub fn verify_proof(
1875 &self,
1876 proof: &Proof<Bls12_381>,
1877 public_inputs: &[Fr],
1878 ) -> Result<bool, SynthesisError> {
1879 Groth16::<Bls12_381>::verify(&self.vk, public_inputs, proof)
1880 }
1881 }
1882}