spawn-zk-snarks 0.1.5

Zero-knowledge proof library with EVM compatibility
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

# spawn-zk-snarks

`spawn-zk-snarks` is a Rust library that provides a robust implementation of Zero-Knowledge Proofs (ZKPs) using the Groth16 proving system. Built on top of the arkworks ecosystem, it offers both high performance and EVM compatibility.

## Features

- **Groth16 Proving System**
  - Generate proving and verification keys
  - Create verifiable proofs for given witnesses
  - Verify proofs with the generated verification keys
  - Efficient constraint system implementation

- **Circuit Implementation**
  - Arithmetic circuit support
  - Constraint generation
  - Witness computation
  - Flexible circuit configuration

- **EVM Compatibility**
  - Generate Solidity verifier contracts
  - EVM-compatible proof format
  - Gas cost estimation
  - Optimized for Ethereum deployment

- **Performance**
  - Fast proof generation (~1.35ms)
  - Efficient verification (~0.76ms)
  - Quick EVM conversion (~0.29µs)
  - Benchmarked and optimized

## Installation

Add this to your `Cargo.toml`:

```toml
[dependencies]
spawn-zk-snarks = "0.1.4"
```

## Quick Start

```rust
use spawn_zk_snarks::{Groth16Setup, ArithmeticCircuit};
use ark_bn254::Fr;
use ark_ff::One;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Setup phase
    let setup = Groth16Setup::new(3, 2)?;

    // Generate proof
    let inputs = vec![Fr::one()];
    let witness = vec![Fr::one(), Fr::one()];
    let proof = setup.prove(&inputs, &witness)?;

    // Verify proof
    let is_valid = setup.verify(&proof, &inputs)?;
    assert!(is_valid);

    // Generate Solidity verifier
    let contract = generate_verifier_contract(&setup.verifying_key)?;

    Ok(())
}
```

## Benchmarks

Performance on M1 MacBook Pro:

```text
proof generation    time:   [1.3244 ms 1.3519 ms 1.3931 ms]
proof verification  time:   [760.30 µs 762.93 µs 765.25 µs]
evm conversion     time:   [289.96 ns 291.12 ns 292.43 ns]
```

+ For detailed benchmark results, analysis and comparisons, see [BENCHMARKS.md](BENCHMARKS.md).
+
+ ### Highlights
+ - **2x** faster verification than generation
+ - **Sub-millisecond** verification time
+ - **Nanosecond** EVM conversion
+ - **Competitive** gas costs

## EVM Integration

```rust
// Generate Solidity verifier contract
let contract = generate_verifier_contract(&setup.verifying_key)?;

// Convert proof to EVM format
let proof_bytes = Groth16Setup::proof_to_evm_format(&proof)?;

// Estimate gas cost
let gas = Groth16Setup::estimate_verification_gas(
    proof_bytes.len(), 
    inputs.len()
);
```

## Testing

Run unit tests:

```bash
cargo test
```

Run benchmarks:

```bash
cargo bench
```

## Security Considerations

- Uses the battle-tested Groth16 proving system
- Built on the arkworks cryptographic library
- Constant-time operations for core cryptographic functions
- Regular security audits recommended before production use

## License

MIT License. See [LICENSE](LICENSE) for details.

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## Acknowledgments

- Built on top of the [arkworks](https://github.com/arkworks-rs) ecosystem
- Uses the BN254 curve implementation from ark-bn254
- Inspired by various ZKP implementations in the blockchain space

## Disclaimer

This library is provided as is, without any security guarantees. Please perform your own security audit before using in production.