ecip benchmark add broken testoid

script/research/zk/ecip-bench/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "ecip-bench"
+version = "0.1.0"
+edition = "2021"
+
+[workspace]
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+darkfi = {path = "../../../../", features = ["zk"]}
+darkfi-sdk = {path = "../../../../src/sdk"}
+halo2_proofs = "0.2.0"
+halo2_gadgets = "0.2.0"
+rand = "0.8.5"
+hex = "0.4.3"
+
+[patch.crates-io]
+halo2_proofs = {git="https://github.com/parazyd/halo2", branch="vk-ser"}
+

script/research/zk/ecip-bench/src/main.rs

@@ -0,0 +1,580 @@
+use rand::rngs::OsRng;
+use std::{marker::PhantomData, time::Instant};
+
+use darkfi_sdk::{
+    crypto::{
+        constants::{
+            sinsemilla::{OrchardCommitDomains, OrchardHashDomains},
+            util::gen_const_array,
+            NullifierK, OrchardFixedBases, OrchardFixedBasesFull, ValueCommitV,
+            MERKLE_DEPTH_ORCHARD,
+        },
+        pallas,
+        pasta_prelude::*,
+    },
+    pasta::group::GroupEncoding,
+};
+use halo2_gadgets::{
+    ecc::{
+        chip::{EccChip, EccConfig},
+        FixedPoint, FixedPointBaseField, FixedPointShort, NonIdentityPoint, Point, ScalarFixed,
+        ScalarFixedShort, ScalarVar,
+    },
+    utilities::lookup_range_check::LookupRangeCheckConfig,
+};
+use halo2_proofs::{
+    arithmetic::FieldExt,
+    circuit::{AssignedCell, Chip, Layouter, Region, SimpleFloorPlanner, Value},
+    plonk::{
+        Advice, Circuit, Column, ConstraintSystem, Error, Fixed, Instance as InstanceColumn,
+        Selector,
+    },
+    poly::Rotation,
+};
+
+use darkfi::zk::{
+    assign_free_advice,
+    gadget::arithmetic::{ArithChip, ArithConfig, ArithInstruction},
+    proof::{Proof, ProvingKey, VerifyingKey},
+};
+
+trait NumericInstructions: Chip<pallas::Base> {
+    /// Variable representing a number.
+    type Num;
+
+    fn load_private(
+        &self,
+        layouter: impl Layouter<pallas::Base>,
+        a: Value<pallas::Base>,
+    ) -> Result<Self::Num, Error>;
+
+    fn load_constant(
+        &self,
+        layouter: impl Layouter<pallas::Base>,
+        constant: pallas::Base,
+    ) -> Result<Self::Num, Error>;
+
+    fn mul(
+        &self,
+        layouter: impl Layouter<pallas::Base>,
+        a: Self::Num,
+        b: Self::Num,
+    ) -> Result<Self::Num, Error>;
+
+    fn expose_public(
+        &self,
+        layouter: impl Layouter<pallas::Base>,
+        num: Self::Num,
+        row: usize,
+    ) -> Result<(), Error>;
+}
+
+/// The chip that will implement our instructions! Chips store their own
+/// config, as well as type markers if necessary.
+struct FieldChip {
+    config: FieldConfig,
+}
+
+/// Chip state is stored in a config struct. This is generated by the chip
+/// during configuration, and then stored inside the chip.
+#[derive(Clone, Debug)]
+struct FieldConfig {
+    /// For this chip, we will use two advice columns to implement our instructions.
+    /// These are also the columns through which we communicate with other parts of
+    /// the circuit.
+    advice: [Column<Advice>; 2],
+
+    /// This is the public input (instance) column.
+    instance: Column<InstanceColumn>,
+
+    // We need a selector to enable the multiplication gate, so that we aren't placing
+    // any constraints on cells where `NumericInstructions::mul` is not being used.
+    // This is important when building larger circuits, where columns are used by
+    // multiple sets of instructions.
+    s_mul: Selector,
+}
+
+impl FieldChip {
+    fn construct(config: <Self as Chip<pallas::Base>>::Config) -> Self {
+        Self { config }
+    }
+
+    fn configure(
+        meta: &mut ConstraintSystem<pallas::Base>,
+        advice: [Column<Advice>; 2],
+        instance: Column<InstanceColumn>,
+        constant: Column<Fixed>,
+    ) -> <Self as Chip<pallas::Base>>::Config {
+        meta.enable_equality(instance);
+        meta.enable_constant(constant);
+        for column in &advice {
+            meta.enable_equality(*column);
+        }
+        let s_mul = meta.selector();
+
+        // Define our multiplication gate!
+        meta.create_gate("mul", |meta| {
+            // To implement multiplication, we need three advice cells and a selector
+            // cell. We arrange them like so:
+            //
+            // | a0  | a1  | s_mul |
+            // |-----|-----|-------|
+            // | lhs | rhs | s_mul |
+            // | out |     |       |
+            //
+            // Gates may refer to any relative offsets we want, but each distinct
+            // offset adds a cost to the proof. The most common offsets are 0 (the
+            // current row), 1 (the next row), and -1 (the previous row), for which
+            // `Rotation` has specific constructors.
+            let lhs = meta.query_advice(advice[0], Rotation::cur());
+            let rhs = meta.query_advice(advice[1], Rotation::cur());
+            let out = meta.query_advice(advice[0], Rotation::next());
+            let s_mul = meta.query_selector(s_mul);
+
+            // Finally, we return the polynomial expressions that constrain this gate.
+            // For our multiplication gate, we only need a single polynomial constraint.
+            //
+            // The polynomial expressions returned from `create_gate` will be
+            // constrained by the proving system to equal zero. Our expression
+            // has the following properties:
+            // - When s_mul = 0, any value is allowed in lhs, rhs, and out.
+            // - When s_mul != 0, this constrains lhs * rhs = out.
+            vec![s_mul * (lhs * rhs - out)]
+        });
+
+        FieldConfig { advice, instance, s_mul }
+    }
+}
+
+impl Chip<pallas::Base> for FieldChip {
+    type Config = FieldConfig;
+    type Loaded = ();
+
+    fn config(&self) -> &Self::Config {
+        &self.config
+    }
+
+    fn loaded(&self) -> &Self::Loaded {
+        &()
+    }
+}
+
+/// A variable representing a number.
+#[derive(Clone)]
+struct Number(AssignedCell<pallas::Base, pallas::Base>);
+
+impl NumericInstructions for FieldChip {
+    type Num = Number;
+
+    fn load_private(
+        &self,
+        mut layouter: impl Layouter<pallas::Base>,
+        value: Value<pallas::Base>,
+    ) -> Result<Self::Num, Error> {
+        let config = self.config();
+
+        layouter.assign_region(
+            || "load private",
+            |mut region| {
+                region.assign_advice(|| "private input", config.advice[0], 0, || value).map(Number)
+            },
+        )
+    }
+
+    fn load_constant(
+        &self,
+        mut layouter: impl Layouter<pallas::Base>,
+        constant: pallas::Base,
+    ) -> Result<Self::Num, Error> {
+        let config = self.config();
+
+        layouter.assign_region(
+            || "load constant",
+            |mut region| {
+                region
+                    .assign_advice_from_constant(|| "constant value", config.advice[0], 0, constant)
+                    .map(Number)
+            },
+        )
+    }
+
+    fn mul(
+        &self,
+        mut layouter: impl Layouter<pallas::Base>,
+        a: Self::Num,
+        b: Self::Num,
+    ) -> Result<Self::Num, Error> {
+        let config = self.config();
+
+        layouter.assign_region(
+            || "mul",
+            |mut region: Region<'_, pallas::Base>| {
+                // We only want to use a single multiplication gate in this region,
+                // so we enable it at region offset 0; this means it will constrain
+                // cells at offsets 0 and 1.
+                config.s_mul.enable(&mut region, 0)?;
+
+                // The inputs we've been given could be located anywhere in the circuit,
+                // but we can only rely on relative offsets inside this region. So we
+                // assign new cells inside the region and constrain them to have the
+                // same values as the inputs.
+                a.0.copy_advice(|| "lhs", &mut region, config.advice[0], 0)?;
+                b.0.copy_advice(|| "rhs", &mut region, config.advice[1], 0)?;
+
+                // Now we can assign the multiplication result, which is to be assigned
+                // into the output position.
+                let value = a.0.value().copied() * b.0.value();
+
+                // Finally, we do the assignment to the output, returning a
+                // variable to be used in another part of the circuit.
+                region.assign_advice(|| "lhs * rhs", config.advice[0], 1, || value).map(Number)
+            },
+        )
+    }
+
+    fn expose_public(
+        &self,
+        mut layouter: impl Layouter<pallas::Base>,
+        num: Self::Num,
+        row: usize,
+    ) -> Result<(), Error> {
+        let config = self.config();
+
+        layouter.constrain_instance(num.0.cell(), config.instance, row)
+    }
+}
+
+#[derive(Clone)]
+pub struct MainConfig {
+    primary: Column<InstanceColumn>,
+    advices: [Column<Advice>; 10],
+    ecc_config: EccConfig<OrchardFixedBases>,
+    arith_config: ArithConfig,
+}
+
+impl MainConfig {
+    fn ecc_chip(&self) -> EccChip<OrchardFixedBases> {
+        EccChip::construct(self.ecc_config.clone())
+    }
+
+    fn arithmetic_chip(&self) -> ArithChip {
+        ArithChip::construct(self.arith_config.clone())
+    }
+}
+
+#[derive(Default)]
+struct MyCircuit {
+    g1: Value<pallas::Point>,
+    //g2: Value<pallas::Point>,
+    //g3: Value<pallas::Point>,
+    //g4: Value<pallas::Point>,
+    s1: Value<pallas::Base>,
+    //s2: Value<pallas::Scalar>,
+    //s3: Value<pallas::Scalar>,
+    //s4: Value<pallas::Scalar>,
+}
+
+impl Circuit<pallas::Base> for MyCircuit {
+    // Since we are using a single chip for everything, we can just reuse its config.
+    type Config = MainConfig;
+    type FloorPlanner = SimpleFloorPlanner;
+
+    fn without_witnesses(&self) -> Self {
+        Self::default()
+    }
+
+    fn configure(meta: &mut ConstraintSystem<pallas::Base>) -> Self::Config {
+        //  Advice columns used in the circuit
+        let advices = [
+            meta.advice_column(),
+            meta.advice_column(),
+            meta.advice_column(),
+            meta.advice_column(),
+            meta.advice_column(),
+            meta.advice_column(),
+            meta.advice_column(),
+            meta.advice_column(),
+            meta.advice_column(),
+            meta.advice_column(),
+        ];
+
+        // Fixed columns for the Sinsemilla generator lookup table
+        let table_idx = meta.lookup_table_column();
+        let lookup = (table_idx, meta.lookup_table_column(), meta.lookup_table_column());
+
+        // Instance column used for public inputs
+        let primary = meta.instance_column();
+        meta.enable_equality(primary);
+
+        // Permutation over all advice columns
+        for advice in advices.iter() {
+            meta.enable_equality(*advice);
+        }
+
+        // Poseidon requires four advice columns, while ECC incomplete addition
+        // requires six. We can reduce the proof size by sharing fixed columns
+        // between the ECC and Poseidon chips.
+        // TODO: For multiple invocations perhaps they could/should be configured
+        // in parallel rather than sharing?
+        let lagrange_coeffs = [
+            meta.fixed_column(),
+            meta.fixed_column(),
+            meta.fixed_column(),
+            meta.fixed_column(),
+            meta.fixed_column(),
+            meta.fixed_column(),
+            meta.fixed_column(),
+            meta.fixed_column(),
+        ];
+        //let rc_a = lagrange_coeffs[2..5].try_into().unwrap();
+        //let rc_b = lagrange_coeffs[5..8].try_into().unwrap();
+
+        // Also use the first Lagrange coefficient column for loading global constants.
+        meta.enable_constant(lagrange_coeffs[0]);
+
+        // Use one of the right-most advice columns for all of our range checks.
+        let range_check = LookupRangeCheckConfig::configure(meta, advices[9], table_idx);
+
+        // Configuration for curve point operations.
+        // This uses 10 advice columns and spans the whole circuit.
+        let ecc_config =
+            EccChip::<OrchardFixedBases>::configure(meta, advices, lagrange_coeffs, range_check);
+
+        // Configuration for the Poseidon hash
+        //let poseidon_config = PoseidonChip::configure::<poseidon::P128Pow5T3>(
+        //    meta,
+        //    advices[6..9].try_into().unwrap(),
+        //    advices[5],
+        //    rc_a,
+        //    rc_b,
+        //);
+
+        // Configuration for the Arithmetic chip
+        let arith_config = ArithChip::configure(meta, advices[7], advices[8], advices[6]);
+
+        // Configuration for a Sinsemilla hash instantiation and a
+        // Merkle hash instantiation using this Sinsemilla instance.
+        // Since the Sinsemilla config uses only 5 advice columns,
+        // we can fit two instances side-by-side.
+        //let (sinsemilla_cfg1, merkle_cfg1) = {
+        //    let sinsemilla_cfg1 = SinsemillaChip::configure(
+        //        meta,
+        //        advices[..5].try_into().unwrap(),
+        //        advices[6],
+        //        lagrange_coeffs[0],
+        //        lookup,
+        //        range_check,
+        //    );
+        //    let merkle_cfg1 = MerkleChip::configure(meta, sinsemilla_cfg1.clone());
+        //    (sinsemilla_cfg1, merkle_cfg1)
+        //};
+
+        //let (_sinsemilla_cfg2, merkle_cfg2) = {
+        //    let sinsemilla_cfg2 = SinsemillaChip::configure(
+        //        meta,
+        //        advices[5..].try_into().unwrap(),
+        //        advices[7],
+        //        lagrange_coeffs[1],
+        //        lookup,
+        //        range_check,
+        //    );
+        //    let merkle_cfg2 = MerkleChip::configure(meta, sinsemilla_cfg2.clone());
+        //    (sinsemilla_cfg2, merkle_cfg2)
+        //};
+
+        // K-table for 64 bit range check lookups
+        let k_values_table_64 = meta.lookup_table_column();
+        //let native_64_range_check_config =
+        //    NativeRangeCheckChip::<3, 64, 22>::configure(meta, advices[8], k_values_table_64);
+
+        // K-table for 253 bit range check lookups
+        let k_values_table_253 = meta.lookup_table_column();
+        //let native_253_range_check_config =
+        //    NativeRangeCheckChip::<3, 253, 85>::configure(meta, advices[8], k_values_table_253);
+
+        // TODO: FIXME: Configure these better, this is just a stop-gap
+        let z1 = meta.advice_column();
+        let z2 = meta.advice_column();
+        //
+        //let lessthan_config = LessThanChip::<3, 253, 85>::configure(
+        //    meta,
+        //    advices[6],
+        //    advices[7],
+        //    advices[8],
+        //    z1,
+        //    z2,
+        //    k_values_table_253,
+        //);
+
+        // Configuration for boolean checks, it uses the small_range_check
+        // chip with a range of 2, which enforces one bit, i.e. 0 or 1.
+        //let boolcheck_config = SmallRangeCheckChip::configure(meta, advices[9], 2);
+
+        MainConfig { primary, advices, ecc_config, arith_config }
+    }
+
+    fn synthesize(
+        &self,
+        config: Self::Config,
+        mut layouter: impl Layouter<pallas::Base>,
+    ) -> Result<(), Error> {
+        let g1 = NonIdentityPoint::new(
+            config.ecc_chip(),
+            layouter.namespace(|| "Witness EcNiPoint"),
+            self.g1.as_ref().map(|cm| cm.to_affine()),
+        )?;
+
+        let s1 = assign_free_advice(layouter.namespace(|| "load a"), config.advices[0], self.s1)?;
+        let s1: AssignedCell<pallas::Base, pallas::Base> = s1.into();
+        let s1 = ScalarVar::from_base(
+            config.ecc_chip(),
+            layouter.namespace(|| "EcMul: ScalarFixed::new()"),
+            &s1,
+        )?;
+        let (r, _) = g1.mul(layouter.namespace(|| "EcMul()"), s1)?;
+
+        let mut public_inputs_offset = 0;
+
+        let point: Point<pallas::Affine, EccChip<OrchardFixedBases>> = r.into();
+        let r_x = point.inner().x();
+        let r_y = point.inner().y();
+
+        let var: AssignedCell<pallas::Base, pallas::Base> = r_x.into();
+        layouter.constrain_instance(var.cell(), config.primary, public_inputs_offset)?;
+        public_inputs_offset += 1;
+
+        let var: AssignedCell<pallas::Base, pallas::Base> = r_y.into();
+        layouter.constrain_instance(var.cell(), config.primary, public_inputs_offset)?;
+        public_inputs_offset += 1;
+
+        Ok(())
+    }
+}
+
+fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
+    let k = 8;
+
+    //let g1 = pallas::Point::random(&mut OsRng);
+    //println!("{:?}", g1);
+    //let g1_bytes = g1.to_bytes();
+    //println!("{}", hex::encode(&g1_bytes));
+
+    // G1_x = 2fea7c1d8106d6d407a57bebec987e875ed9073ebf215e52f5b42c0c604c1801
+    // G1_y = 0dcc7041075d6496102295722cd12f2f0c1e9d49eaa00f10c4bc02155598353b
+    // G2_x = dfae4ed869484b2b9783c445888db03bac24f96f0260982b90f5b53477994e3e
+    // G2_y = fa1b4182ef04514624a1e32846d48bfd229ef78975106e8e0614b8061dfe3d1d
+    // G3_x = 702ddc6514ae63da6e13bcfa439f03b363018a152e16e665126623205ac4d31c
+    // G3_y = 81cb38e121b6c375150aa2c1b4c92185a87781194a133535cbefb699e3475103
+    // G4_x = 026b681bf7a0102e78bf3b34af50b5031ef1dd1f152f3df17af8e6eaae69cb3a
+    // G4_y = c97b4f5ed89f4147eb3410892af8a1ecd21b96f59d43e5e4252872742acbbf24
+
+    // s1 = f4537d29a235d6b4bf95ef436aa15fd641419c2da9e9600520be99a14c43ac2c
+    // s2 = 6d2738d1e1f8bbb1bd154cd8102cca5c0224f8902803da1f7c4563b47103471c
+    // s3 = ebbaf604f85b3e725e71a5d785e177c9f3ccd4c07394a0d59318cf1504c72a06
+    // s4 = 5176cd889dd29f19cef07c5d2db9a2d67c568034ae737ff1f95456252d2e2301
+
+    // Qx = 6b35d97bcef7928a15aed8e5d9b8ecbcb2a5ca190de7b9957971f6da6ad92c03
+    // Qy = e485978ca7d9f798fe1b7afac7f74a98326cccc528f1010091948497ae5e7422
+
+    // Halo2 points are the x coordinated in little endian order
+    let g1x_bytes =
+        hex::decode("2fea7c1d8106d6d407a57bebec987e875ed9073ebf215e52f5b42c0c604c1801")?;
+    let g1x_bytes = g1x_bytes[..].try_into()?;
+    let g1x = pallas::Base::from_repr(g1x_bytes).unwrap();
+    let g1y_bytes =
+        hex::decode("0dcc7041075d6496102295722cd12f2f0c1e9d49eaa00f10c4bc02155598353b")?;
+    let g1y_bytes = g1y_bytes[..].try_into()?;
+    let g1y = pallas::Base::from_repr(g1y_bytes).unwrap();
+    let g1: pallas::Point = pallas::Affine::from_xy(g1x, g1y).unwrap().into();
+
+    //let g2x_bytes = hex::decode("dfae4ed869484b2b9783c445888db03bac24f96f0260982b90f5b53477994e3e")?;
+    //let g2x_bytes = g2x_bytes[..].try_into()?;
+    //let g2x = pallas::Base::from_repr(g2x_bytes).unwrap();
+    //let g2y_bytes = hex::decode("fa1b4182ef04514624a1e32846d48bfd229ef78975106e8e0614b8061dfe3d1d")?;
+    //let g2y_bytes = g2y_bytes[..].try_into()?;
+    //let g2y = pallas::Base::from_repr(g2y_bytes).unwrap();
+    //let g2: pallas::Point = pallas::Affine::from_xy(g2x, g2y).unwrap().into();
+
+    //let g3x_bytes = hex::decode("702ddc6514ae63da6e13bcfa439f03b363018a152e16e665126623205ac4d31c")?;
+    //let g3x_bytes = g3x_bytes[..].try_into()?;
+    //let g3x = pallas::Base::from_repr(g3x_bytes).unwrap();
+    //let g3y_bytes = hex::decode("81cb38e121b6c375150aa2c1b4c92185a87781194a133535cbefb699e3475103")?;
+    //let g3y_bytes = g3y_bytes[..].try_into()?;
+    //let g3y = pallas::Base::from_repr(g3y_bytes).unwrap();
+    //let g3: pallas::Point = pallas::Affine::from_xy(g3x, g3y).unwrap().into();
+
+    //let g4x_bytes = hex::decode("026b681bf7a0102e78bf3b34af50b5031ef1dd1f152f3df17af8e6eaae69cb3a")?;
+    //let g4x_bytes = g4x_bytes[..].try_into()?;
+    //let g4x = pallas::Base::from_repr(g4x_bytes).unwrap();
+    //let g4y_bytes = hex::decode("c97b4f5ed89f4147eb3410892af8a1ecd21b96f59d43e5e4252872742acbbf24")?;
+    //let g4y_bytes = g4y_bytes[..].try_into()?;
+    //let g4y = pallas::Base::from_repr(g4y_bytes).unwrap();
+    //let g4: pallas::Point = pallas::Affine::from_xy(g4x, g4y).unwrap().into();
+
+    //let s1_bytes = hex::decode("f4537d29a235d6b4bf95ef436aa15fd641419c2da9e9600520be99a14c43ac2c")?;
+    //let s1_bytes = s1_bytes[..].try_into()?;
+    //let s1 = pallas::Scalar::from_repr(s1_bytes).unwrap();
+
+    //let s2_bytes = hex::decode("6d2738d1e1f8bbb1bd154cd8102cca5c0224f8902803da1f7c4563b47103471c")?;
+    //let s2_bytes = s2_bytes[..].try_into()?;
+    //let s2 = pallas::Scalar::from_repr(s2_bytes).unwrap();
+
+    //let s3_bytes = hex::decode("ebbaf604f85b3e725e71a5d785e177c9f3ccd4c07394a0d59318cf1504c72a06")?;
+    //let s3_bytes = s3_bytes[..].try_into()?;
+    //let s3 = pallas::Scalar::from_repr(s3_bytes).unwrap();
+
+    //let s4_bytes = hex::decode("5176cd889dd29f19cef07c5d2db9a2d67c568034ae737ff1f95456252d2e2301")?;
+    //let s4_bytes = s4_bytes[..].try_into()?;
+    //let s4 = pallas::Scalar::from_repr(s4_bytes).unwrap();
+
+    //let qx_bytes = hex::decode("6b35d97bcef7928a15aed8e5d9b8ecbcb2a5ca190de7b9957971f6da6ad92c03")?;
+    //let qx_bytes = qx_bytes[..].try_into()?;
+    //let qx = pallas::Base::from_repr(qx_bytes).unwrap();
+    //let qy_bytes = hex::decode("e485978ca7d9f798fe1b7afac7f74a98326cccc528f1010091948497ae5e7422")?;
+    //let qy_bytes = qy_bytes[..].try_into()?;
+    //let qy = pallas::Base::from_repr(qy_bytes).unwrap();
+    //let q: pallas::Point = pallas::Affine::from_xy(qx, qy).unwrap().into();
+
+    //let x = pallas::Scalar::from(2);
+    //println!("{:?}", x);
+    //println!("{:?}", x.to_repr());
+
+    //let qq = g1*s1 + g2*s2 + g3*s3 + g4*s4;
+    //println!("{:?}", qq.to_affine());
+    //assert_eq!(q.to_affine(), qq.to_affine());
+
+    let r = g1 * pallas::Scalar::from(2);
+
+    let s1 = pallas::Base::from(2);
+
+    let circuit = MyCircuit {
+        g1: Value::known(g1),
+        //g2: Value::known(g2),
+        //g3: Value::known(g3),
+        //g4: Value::known(g4),
+        s1: Value::known(s1),
+        //s2: Value::known(s2),
+        //s3: Value::known(s3),
+        //s4: Value::known(s4),
+    };
+
+    let r_coords = r.to_affine().coordinates().unwrap();
+    let r_x = *r_coords.x();
+    let r_y = *r_coords.y();
+
+    let public = vec![r_x, r_y];
+
+    let start = Instant::now();
+    let pk = darkfi::zk::ProvingKey::build(k, &MyCircuit::default());
+    let vk = darkfi::zk::VerifyingKey::build(k, &MyCircuit::default());
+    println!("Setup: [{:?}]", start.elapsed());
+
+    let start = Instant::now();
+    let proof = Proof::create(&pk, &[circuit], &public, &mut OsRng)?;
+    println!("Prove: [{:?}]", start.elapsed());
+
+    let start = Instant::now();
+    assert!(proof.verify(&vk, &public).is_ok());
+    println!("Verify: [{:?}]", start.elapsed());
+    Ok(())
+}