Proving key pre-loading (#51)

* switch to per spec RPC server

* fix verifier circuits keys loading

Cargo.toml

@@ -77,14 +77,16 @@ pasta_curves = "0.5.1"
 ff = "0.13"
 sha2 = { version = "0.9", features = ["compress"] }
 uint = "0.9.1"
-ark-std = { version = "0.4.0", features = ["print-trace"] }
 
 # misc
 itertools = "0.12.0"
 serde = { version = "1.0.130", features = ["derive"] }
 serde_json = "1.0.78"
+getset = "0.1.2"
 log = "0.4.14"
 hex = "0.4"
+ark-std = { version = "0.4.0", features = ["print-trace"] }
+
 
 [patch.crates-io]
 halo2curves = { git = "https://github.com/timoftime/halo2curves", package = "halo2curves-axiom", rev = "1bd39b8" }

eth-types/src/spec.rs

@@ -6,6 +6,7 @@ use core::fmt::Debug;
 
 /// Beacon chain specification.
 pub trait Spec: 'static + Sized + Copy + Default + Debug {
+    const NAME: &'static str;
     const SYNC_COMMITTEE_SIZE: usize;
     const SYNC_COMMITTEE_ROOT_INDEX: usize;
     const SYNC_COMMITTEE_DEPTH: usize;
@@ -25,6 +26,7 @@ pub trait Spec: 'static + Sized + Copy + Default + Debug {
 pub struct Minimal;
 
 impl Spec for Minimal {
+    const NAME: &'static str = "minimal";
     const SYNC_COMMITTEE_SIZE: usize = 32;
     const SYNC_COMMITTEE_DEPTH: usize = 5;
     const SYNC_COMMITTEE_ROOT_INDEX: usize = 55;
@@ -45,6 +47,7 @@ impl Spec for Minimal {
 pub struct Testnet;
 
 impl Spec for Testnet {
+    const NAME: &'static str = "testnet";
     const SYNC_COMMITTEE_SIZE: usize = 512;
     const SYNC_COMMITTEE_DEPTH: usize = 5;
     const SYNC_COMMITTEE_ROOT_INDEX: usize = 55;
@@ -64,6 +67,7 @@ impl Spec for Testnet {
 pub struct Mainnet;
 
 impl Spec for Mainnet {
+    const NAME: &'static str = "mainnet";
     const SYNC_COMMITTEE_SIZE: usize = 512;
     const SYNC_COMMITTEE_DEPTH: usize = 5;
     const SYNC_COMMITTEE_ROOT_INDEX: usize = 55;

lightclient-circuits/tests/step.rs

@@ -92,13 +92,11 @@ fn run_test_eth2_spec_mock<const K_ROTATION: u32, const K_SYNC: u32>(path: PathB
 
     let rotation_circuit = mock_committee_update_circuit(&rotation_witness, K_ROTATION, None);
 
+    let rotation_instance =
+        CommitteeUpdateCircuit::<Minimal, bn256::Fr>::get_instances(&rotation_witness, LIMB_BITS);
     let timer = start_timer!(|| "committee_update mock prover run");
-    let prover = MockProver::<bn256::Fr>::run(
-        K_ROTATION,
-        &rotation_circuit,
-        CommitteeUpdateCircuit::<Minimal, bn256::Fr>::get_instances(&rotation_witness, LIMB_BITS),
-    )
-    .unwrap();
+    let prover =
+        MockProver::<bn256::Fr>::run(K_ROTATION, &rotation_circuit, rotation_instance).unwrap();
     prover.assert_satisfied_par();
     end_timer!(timer);
 

prover/Cargo.toml

@@ -39,6 +39,7 @@ ark-std.workspace = true
 itertools.workspace = true
 serde.workspace = true
 serde_json.workspace = true
+getset.workspace = true
 log.workspace = true
 url = "2"
 

prover/src/args.rs

@@ -37,6 +37,14 @@ pub enum BaseCmd {
         /// Port for RPC server to listen on
         #[clap(long, short, default_value = "3000")]
         port: String,
+
+        /// Network specification [mainnet, testnet]
+        #[clap(long, short, default_value = "mainnet")]
+        spec: Spec,
+
+        /// Path to directory with circuit artifacts
+        #[clap(long, short, default_value = "./build")]
+        build_dir: PathBuf,
     },
     /// Circuit related commands.
     Circuit {

prover/src/lib.rs

@@ -4,6 +4,8 @@
 
 #![allow(incomplete_features)]
 #![feature(generic_const_exprs)]
+pub mod prover;
+
 pub mod rpc_api;
 pub mod rpc_client;
 

prover/src/main.rs

@@ -20,8 +20,30 @@ mod args;
 
 async fn app(options: Cli) -> eyre::Result<()> {
     match options.subcommand {
-        args::BaseCmd::Rpc { port } => {
-            run_rpc(port.parse().unwrap()).await?;
+        args::BaseCmd::Rpc {
+            port,
+            spec,
+            build_dir,
+        } => {
+            match spec {
+                args::Spec::Testnet => {
+                    run_rpc::<eth_types::Testnet>(
+                        port.parse().unwrap(),
+                        options.args.config_dir,
+                        build_dir,
+                    )
+                    .await
+                }
+                args::Spec::Mainnet => {
+                    run_rpc::<eth_types::Mainnet>(
+                        port.parse().unwrap(),
+                        options.args.config_dir,
+                        build_dir,
+                    )
+                    .await
+                }
+                args::Spec::Minimal => Err(eyre::eyre!("Minimal spec is not supported for RPC")),
+            }?;
 
             log::info!("Stopped accepting RPC connections");
 

prover/src/prover.rs

@@ -0,0 +1,114 @@
+// The Licensed Work is (c) 2023 ChainSafe
+// Code: https://github.com/ChainSafe/Spectre
+// SPDX-License-Identifier: LGPL-3.0-only
+
+use eth_types::Spec;
+use getset::Getters;
+use lightclient_circuits::committee_update_circuit::CommitteeUpdateCircuit;
+use lightclient_circuits::halo2_base::utils::fs::gen_srs;
+use lightclient_circuits::halo2_proofs::{
+    halo2curves::bn256::{Bn256, Fr, G1Affine},
+    plonk::ProvingKey,
+    poly::kzg::commitment::ParamsKZG,
+};
+use lightclient_circuits::sync_step_circuit::StepCircuit;
+use lightclient_circuits::util::AppCircuit;
+use snark_verifier_sdk::halo2::aggregation::AggregationCircuit;
+use std::collections::BTreeMap;
+use std::path::{Path, PathBuf};
+
+#[derive(Clone, Debug, Getters)]
+pub struct CircuitContext {
+    #[getset(get = "pub")]
+    pub config_path: PathBuf,
+    #[getset(get = "pub")]
+    pub degree: u32,
+    #[getset(get = "pub")]
+    pub pk: ProvingKey<G1Affine>,
+}
+
+#[derive(Clone, Debug)]
+pub struct ProverState {
+    // degree -> params (use BTreeMap to find proper degree for params downsize)
+    pub params: BTreeMap<u32, ParamsKZG<Bn256>>,
+    pub step: CircuitContext,
+    pub step_verifier: CircuitContext,
+    pub committee_update: CircuitContext,
+    pub committee_update_verifier: CircuitContext,
+}
+
+impl ProverState {
+    pub fn new<S: Spec>(config_dir: &Path, build_dir: &Path) -> Self {
+        let mut params_map = BTreeMap::new();
+
+        fn load_ctx<Circuit: AppCircuit>(
+            config_path: PathBuf,
+            pk_path: PathBuf,
+            params_map: &mut BTreeMap<u32, ParamsKZG<Bn256>>,
+            default_witness: Circuit::Witness,
+        ) -> CircuitContext {
+            let degree = Circuit::get_degree(&config_path);
+            let params = gen_srs(degree);
+
+            let pk = Circuit::read_pk(&params, pk_path, &config_path, &default_witness);
+
+            params_map.insert(degree, params);
+
+            CircuitContext {
+                config_path,
+                degree,
+                pk,
+            }
+        }
+
+        let step = load_ctx::<StepCircuit<S, Fr>>(
+            config_dir.join(format!("sync_step_{}.json", S::NAME)),
+            build_dir.join(format!("sync_step_{}.pkey", S::NAME)),
+            &mut params_map,
+            Default::default(),
+        );
+
+        let step_snark = StepCircuit::<S, Fr>::gen_snark_shplonk(
+            params_map.get(step.degree()).unwrap(),
+            step.pk(),
+            step.config_path(),
+            None::<String>,
+            &Default::default(),
+        )
+        .unwrap();
+
+        let committee_update = load_ctx::<CommitteeUpdateCircuit<S, Fr>>(
+            config_dir.join(format!("committee_update_{}.json", S::NAME)),
+            build_dir.join(format!("committee_update_{}.pkey", S::NAME)),
+            &mut params_map,
+            Default::default(),
+        );
+
+        let committee_update_snark = CommitteeUpdateCircuit::<S, Fr>::gen_snark_shplonk(
+            params_map.get(committee_update.degree()).unwrap(),
+            committee_update.pk(),
+            committee_update.config_path(),
+            None::<String>,
+            &Default::default(),
+        )
+        .unwrap();
+
+        Self {
+            step,
+            step_verifier: load_ctx::<AggregationCircuit>(
+                config_dir.join(format!("sync_step_verifier_{}.json", S::NAME)),
+                build_dir.join(format!("sync_step_verifier_{}.pkey", S::NAME)),
+                &mut params_map,
+                vec![step_snark],
+            ),
+            committee_update,
+            committee_update_verifier: load_ctx::<AggregationCircuit>(
+                config_dir.join(format!("committee_update_verifier_{}.json", S::NAME)),
+                build_dir.join(format!("committee_update_verifier_{}.pkey", S::NAME)),
+                &mut params_map,
+                vec![committee_update_snark],
+            ),
+            params: params_map,
+        }
+    }
+}