ethdos-fold/src/lib.rs
src/lib.rsRaw
1//! This file contains the WASM bindings.
2//!
3#![allow(non_snake_case)]
4#![allow(dead_code)]
5#![allow(non_camel_case_types)]
6#![allow(clippy::upper_case_acronyms)]
7
8use ark_bn254::{Fr, G1Projective as G1};
9use ark_ec::AffineRepr;
10use ark_grumpkin::Projective as G2;
11use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
12use ark_std::Zero;
13use base64::{engine::general_purpose::STANDARD as b64, Engine as _};
14use rand::rngs::OsRng;
15
16use arkeddsa::ed_on_bn254_twist::{constraints::EdwardsVar, EdwardsProjective};
17
18use folding_schemes::{
19 commitment::pedersen::Pedersen,
20 folding::nova::{Nova, PreprocessorParam},
21 frontend::FCircuit,
22 transcript::poseidon::poseidon_canonical_config,
23 FoldingScheme,
24};
25
26use crate::fcircuit::EthDosCircuit;
27use crate::signature::{gen_signatures, SigPk};
28use crate::utils::{dbg, elapsed, get_time};
29
30mod fcircuit;
31mod fold_ethdos;
32mod signature;
33mod utils;
34
35use wasm_bindgen::prelude::*;
36
37// define type aliases for the FCircuit (FC) and the FoldingScheme (FS), to avoid writting the
38// whole type each time.
39type FC = EthDosCircuit<Fr, EdwardsProjective, EdwardsVar>;
40type FS = Nova<G1, G2, FC, Pedersen<G1>, Pedersen<G2>, false>;
41
42#[wasm_bindgen]
43extern "C" {
44 fn alert(s: &str);
45}
46
47#[wasm_bindgen]
48pub fn gen_params() -> Vec<String> {
49 let mut rng = OsRng;
50 let poseidon_config = poseidon_canonical_config::<Fr>();
51
52 let f_circuit = FC::new(poseidon_config.clone()).unwrap();
53
54 let nova_preprocess_params = PreprocessorParam::new(poseidon_config.clone(), f_circuit.clone());
55 let start = get_time();
56 let nova_params = FS::preprocess(&mut rng, &nova_preprocess_params).unwrap();
57 dbg(format!("Nova params generated: {:?}ms", elapsed(start)));
58
59 // serialize
60 let start = get_time();
61 let mut prover_params_serialized = vec![];
62 nova_params
63 .0
64 .serialize_compressed(&mut prover_params_serialized)
65 .unwrap();
66 dbg(format!(
67 "Nova prover params serialized: {:?}ms",
68 elapsed(start)
69 ));
70
71 let start = get_time();
72 let mut verifier_params_serialized = vec![];
73 nova_params
74 .1
75 .serialize_compressed(&mut verifier_params_serialized)
76 .unwrap();
77 dbg(format!(
78 "Nova prover params serialized: {:?}ms",
79 elapsed(start)
80 ));
81
82 vec![
83 b64.encode(&prover_params_serialized),
84 b64.encode(&prover_params_serialized),
85 ]
86}
87
88#[wasm_bindgen]
89pub fn gen_sigs(n_steps: usize) -> Vec<String> {
90 let mut rng = OsRng;
91 let poseidon_config = poseidon_canonical_config::<Fr>();
92
93 let sigs: Vec<SigPk<EdwardsProjective>> = gen_signatures(&mut rng, &poseidon_config, n_steps);
94 let b: Vec<Vec<u8>> = sigs.iter().map(|&s| s.to_bytes()).collect();
95 b.iter().map(|s| b64.encode(s)).collect::<Vec<String>>()
96}
97
98#[wasm_bindgen]
99pub fn fold_sigs(params: Vec<String>, sigs_pks: Vec<String>) -> String {
100 dbg("starting fold_sigs (rust)".to_string());
101 dbg(format!("received sigs: {:?}", sigs_pks));
102
103 let poseidon_config = poseidon_canonical_config::<Fr>();
104
105 // parse sigs_pks
106 let b: Vec<Vec<u8>> = sigs_pks.iter().map(|s| b64.decode(s).unwrap()).collect();
107 let pks_sigs: Vec<SigPk<EdwardsProjective>> =
108 b.iter().map(|s| SigPk::from_bytes(s.clone())).collect();
109
110 // parse params
111 let start = get_time();
112 let pp = FS::pp_deserialize_with_mode(
113 &mut b64.decode(params[0].clone()).unwrap().as_slice(),
114 ark_serialize::Compress::Yes,
115 ark_serialize::Validate::Yes,
116 poseidon_config.clone(), // fcircuit_params
117 )
118 .unwrap();
119 let vp = FS::vp_deserialize_with_mode(
120 &mut b64.decode(params[1].clone()).unwrap().as_slice(),
121 ark_serialize::Compress::Yes,
122 ark_serialize::Validate::Yes,
123 poseidon_config.clone(), // fcircuit_params
124 )
125 .unwrap();
126 let fs_params = (pp, vp);
127 dbg(format!(
128 "params (prover & verifier) deserialization: {:?}ms",
129 elapsed(start)
130 ));
131
132 // set the initial state
133 let xy = pks_sigs[0].pk.0.xy().unwrap();
134 let pk0 = vec![xy.0, xy.1];
135 let z_0: Vec<Fr> = [pk0.clone(), pk0, vec![Fr::zero()]].concat();
136
137 type FC = EthDosCircuit<Fr, EdwardsProjective, EdwardsVar>;
138 let f_circuit = FC::new(poseidon_config.clone()).unwrap();
139
140 // initialize the folding scheme engine, in our case we use Nova
141 let mut nova = FS::init(&fs_params, f_circuit, z_0.clone()).unwrap();
142 let rng = OsRng;
143 let n_steps = sigs_pks.len();
144
145 let start_full = get_time();
146 #[allow(clippy::needless_range_loop)]
147 for i in 0..n_steps {
148 let start = get_time();
149 nova.prove_step(rng, pks_sigs[i], None).unwrap();
150 dbg(format!(
151 "Nova::prove_step {}: {:?}ms",
152 nova.i,
153 elapsed(start)
154 ));
155 }
156 dbg(format!(
157 "Nova's all {} steps time: {:?}ms",
158 n_steps,
159 elapsed(start_full)
160 ));
161
162 let ivc_proof = nova.ivc_proof();
163 let mut ivc_proof_bytes = vec![];
164 ivc_proof
165 .serialize_compressed(&mut ivc_proof_bytes)
166 .unwrap();
167
168 b64.encode(ivc_proof_bytes)
169}
170
171#[wasm_bindgen]
172pub fn verify_proof(verifier_params: String, ivc_proof: String) -> String {
173 let poseidon_config = poseidon_canonical_config::<Fr>();
174
175 let vp = FS::vp_deserialize_with_mode(
176 &mut b64.decode(verifier_params.clone()).unwrap().as_slice(),
177 ark_serialize::Compress::Yes,
178 ark_serialize::Validate::Yes,
179 poseidon_config.clone(), // fcircuit_params
180 )
181 .unwrap();
182 // let proof =
183 // FS::IVCProof::deserialize_compressed(b64.decode(ivc_proof).unwrap().as_slice()).unwrap();
184 let proof = <Nova<G1, G2, FC, Pedersen<G1>, Pedersen<G2>, false> as FoldingScheme<
185 G1,
186 G2,
187 FC,
188 >>::IVCProof::deserialize_compressed(b64.decode(ivc_proof).unwrap().as_slice())
189 .unwrap();
190
191 FS::verify(
192 vp, // Nova's verifier params
193 proof,
194 )
195 .unwrap();
196 "verified".to_string()
197}