Use k param from ZkBinary when building VerifyingKey and ProvingKey.

bin/drk/src/rpc_dao.rs

@@ -74,10 +74,9 @@ impl Drk {
         };
 
         let dao_mint_zkbin = ZkBinary::decode(&dao_mint_zkbin.1)?;
-        let k = 13;
         let dao_mint_circuit = ZkCircuit::new(empty_witnesses(&dao_mint_zkbin), &dao_mint_zkbin);
         eprintln!("Creating DAO Mint proving key");
-        let dao_mint_pk = ProvingKey::build(k, &dao_mint_circuit);
+        let dao_mint_pk = ProvingKey::build(dao_mint_zkbin.k, &dao_mint_circuit);
 
         let (params, proofs) =
             dao_client::make_mint_call(&dao_info, &dao.secret_key, &dao_mint_zkbin, &dao_mint_pk)?;
@@ -163,16 +162,15 @@ impl Drk {
         let propose_burn_zkbin = ZkBinary::decode(&propose_burn_zkbin.1)?;
         let propose_main_zkbin = ZkBinary::decode(&propose_main_zkbin.1)?;
 
-        let k = 13;
         let propose_burn_circuit =
             ZkCircuit::new(empty_witnesses(&propose_burn_zkbin), &propose_burn_zkbin);
         let propose_main_circuit =
             ZkCircuit::new(empty_witnesses(&propose_main_zkbin), &propose_main_zkbin);
 
         eprintln!("Creating Propose Burn circuit proving key");
-        let propose_burn_pk = ProvingKey::build(k, &propose_burn_circuit);
+        let propose_burn_pk = ProvingKey::build(propose_burn_zkbin.k, &propose_burn_circuit);
         eprintln!("Creating Propose Main circuit proving key");
-        let propose_main_pk = ProvingKey::build(k, &propose_main_circuit);
+        let propose_main_pk = ProvingKey::build(propose_main_zkbin.k, &propose_main_circuit);
 
         // Now create the parameters for the proposal tx
         let signature_secret = SecretKey::random(&mut OsRng);
@@ -348,16 +346,15 @@ impl Drk {
         let dao_vote_burn_zkbin = ZkBinary::decode(&dao_vote_burn_zkbin.1)?;
         let dao_vote_main_zkbin = ZkBinary::decode(&dao_vote_main_zkbin.1)?;
 
-        let k = 13;
         let dao_vote_burn_circuit =
             ZkCircuit::new(empty_witnesses(&dao_vote_burn_zkbin), &dao_vote_burn_zkbin);
         let dao_vote_main_circuit =
             ZkCircuit::new(empty_witnesses(&dao_vote_main_zkbin), &dao_vote_main_zkbin);
 
         eprintln!("Creating DAO Vote Burn proving key");
-        let dao_vote_burn_pk = ProvingKey::build(k, &dao_vote_burn_circuit);
+        let dao_vote_burn_pk = ProvingKey::build(dao_vote_burn_zkbin.k, &dao_vote_burn_circuit);
         eprintln!("Creating DAO Vote Main proving key");
-        let dao_vote_main_pk = ProvingKey::build(k, &dao_vote_main_circuit);
+        let dao_vote_main_pk = ProvingKey::build(dao_vote_main_zkbin.k, &dao_vote_main_circuit);
 
         let (params, proofs) = call.make(
             &dao_vote_burn_zkbin,
@@ -417,13 +414,12 @@ impl Drk {
         };
         let mint_zkbin = ZkBinary::decode(&mint_zkbin.1)?;
         let burn_zkbin = ZkBinary::decode(&burn_zkbin.1)?;
-        let k = 13;
         let mint_circuit = ZkCircuit::new(empty_witnesses(&mint_zkbin), &mint_zkbin);
         let burn_circuit = ZkCircuit::new(empty_witnesses(&burn_zkbin), &burn_zkbin);
         eprintln!("Creating Money Mint circuit proving key");
-        let mint_pk = ProvingKey::build(k, &mint_circuit);
+        let mint_pk = ProvingKey::build(mint_zkbin.k, &mint_circuit);
         eprintln!("Creating Money Burn circuit proving key");
-        let burn_pk = ProvingKey::build(k, &burn_circuit);
+        let burn_pk = ProvingKey::build(burn_zkbin.k, &burn_circuit);
 
         let xfer_builder = TransferCallBuilder {
             keypair: dao.keypair(),
@@ -459,7 +455,7 @@ impl Drk {
         let exec_zkbin = ZkBinary::decode(&exec_zkbin.1)?;
         let exec_circuit = ZkCircuit::new(empty_witnesses(&exec_zkbin), &exec_zkbin);
         eprintln!("Creating DAO Exec circuit proving key");
-        let exec_pk = ProvingKey::build(k, &exec_circuit);
+        let exec_pk = ProvingKey::build(exec_zkbin.k, &exec_circuit);
 
         // Count votes
         let mut total_yes_vote_value = 0;

bin/drk/src/rpc_swap.rs

@@ -122,7 +122,6 @@ impl Drk {
         let mint_zkbin = ZkBinary::decode(&mint_zkbin.1)?;
         let burn_zkbin = ZkBinary::decode(&burn_zkbin.1)?;
 
-        let k = 13;
         let mint_circuit = ZkCircuit::new(empty_witnesses(&mint_zkbin), &mint_zkbin);
         let burn_circuit = ZkCircuit::new(empty_witnesses(&burn_zkbin), &burn_zkbin);
 
@@ -132,6 +131,8 @@ impl Drk {
 
         // Now we should have everything we need to build the swap half
         eprintln!("Creating Mint and Burn circuit proving keys");
+        let mint_pk = ProvingKey::build(mint_zkbin.k, &mint_circuit);
+        let burn_pk = ProvingKey::build(burn_zkbin.k, &burn_circuit);
         let builder = SwapCallBuilder {
             pubkey: address,
             value_send,
@@ -146,9 +147,9 @@ impl Drk {
             coin: burn_coin,
             tree,
             mint_zkbin,
-            mint_pk: ProvingKey::build(k, &mint_circuit),
+            mint_pk,
             burn_zkbin,
-            burn_pk: ProvingKey::build(k, &burn_circuit),
+            burn_pk,
         };
 
         eprintln!("Building first half of the swap transaction");
@@ -214,7 +215,6 @@ impl Drk {
         let mint_zkbin = ZkBinary::decode(&mint_zkbin.1)?;
         let burn_zkbin = ZkBinary::decode(&burn_zkbin.1)?;
 
-        let k = 13;
         let mint_circuit = ZkCircuit::new(empty_witnesses(&mint_zkbin), &mint_zkbin);
         let burn_circuit = ZkCircuit::new(empty_witnesses(&burn_zkbin), &burn_zkbin);
 
@@ -222,6 +222,8 @@ impl Drk {
 
         // Now we should have everything we need to build the swap half
         eprintln!("Creating Mint and Burn circuit proving keys");
+        let mint_pk = ProvingKey::build(mint_zkbin.k, &mint_circuit);
+        let burn_pk = ProvingKey::build(burn_zkbin.k, &burn_circuit);
         let builder = SwapCallBuilder {
             pubkey: address,
             value_send: partial.value_pair.1,
@@ -236,9 +238,9 @@ impl Drk {
             coin: burn_coin,
             tree,
             mint_zkbin,
-            mint_pk: ProvingKey::build(k, &mint_circuit),
+            mint_pk,
             burn_zkbin,
-            burn_pk: ProvingKey::build(k, &burn_circuit),
+            burn_pk,
         };
 
         eprintln!("Building second half of the swap transaction");

bin/drk/src/rpc_token.rs

@@ -74,12 +74,12 @@ impl Drk {
             return Err(anyhow!("Token mint circuit not found"))
         };
 
-        let k = 13;
         let token_mint_zkbin = ZkBinary::decode(&token_mint_zkbin.1)?;
         let token_mint_circuit =
             ZkCircuit::new(empty_witnesses(&token_mint_zkbin), &token_mint_zkbin);
 
         eprintln!("Creating token mint circuit proving keys");
+        let token_mint_pk = ProvingKey::build(token_mint_zkbin.k, &token_mint_circuit);
         let mint_builder = TokenMintCallBuilder {
             mint_authority,
             recipient,
@@ -87,7 +87,7 @@ impl Drk {
             spend_hook,
             user_data,
             token_mint_zkbin,
-            token_mint_pk: ProvingKey::build(k, &token_mint_circuit),
+            token_mint_pk,
         };
 
         eprintln!("Building transaction parameters");
@@ -127,17 +127,14 @@ impl Drk {
             return Err(anyhow!("Token freeze circuit not found"))
         };
 
-        let k = 13;
         let token_freeze_zkbin = ZkBinary::decode(&token_freeze_zkbin.1)?;
         let token_freeze_circuit =
             ZkCircuit::new(empty_witnesses(&token_freeze_zkbin), &token_freeze_zkbin);
 
         eprintln!("Creating token freeze circuit proving keys");
-        let freeze_builder = TokenFreezeCallBuilder {
-            mint_authority,
-            token_freeze_zkbin,
-            token_freeze_pk: ProvingKey::build(k, &token_freeze_circuit),
-        };
+        let token_freeze_pk = ProvingKey::build(token_freeze_zkbin.k, &token_freeze_circuit);
+        let freeze_builder =
+            TokenFreezeCallBuilder { mint_authority, token_freeze_zkbin, token_freeze_pk };
 
         eprintln!("Building transaction parameters");
         let debris = freeze_builder.build()?;

bin/drk/src/rpc_transfer.rs

@@ -123,11 +123,12 @@ impl Drk {
         let mint_zkbin = ZkBinary::decode(&mint_zkbin.1)?;
         let burn_zkbin = ZkBinary::decode(&burn_zkbin.1)?;
 
-        let k = 13;
         let mint_circuit = ZkCircuit::new(empty_witnesses(&mint_zkbin), &mint_zkbin);
         let burn_circuit = ZkCircuit::new(empty_witnesses(&burn_zkbin), &burn_zkbin);
 
         eprintln!("Creating Mint and Burn circuit proving keys");
+        let mint_pk = ProvingKey::build(mint_zkbin.k, &mint_circuit);
+        let burn_pk = ProvingKey::build(burn_zkbin.k, &burn_circuit);
         let transfer_builder = TransferCallBuilder {
             keypair,
             recipient,
@@ -142,9 +143,9 @@ impl Drk {
             coins: owncoins,
             tree,
             mint_zkbin,
-            mint_pk: ProvingKey::build(k, &mint_circuit),
+            mint_pk,
             burn_zkbin,
-            burn_pk: ProvingKey::build(k, &burn_circuit),
+            burn_pk,
             clear_input: false,
         };
 

bin/faucetd/src/main.rs

@@ -238,7 +238,6 @@ impl Faucetd {
         let (mint_zkbin, _): (Vec<u8>, Vec<u8>) = deserialize(&mint_zkbytes)?;
         let (burn_zkbin, _): (Vec<u8>, Vec<u8>) = deserialize(&burn_zkbytes)?;
 
-        let k = 13;
         let mint_zkbin = ZkBinary::decode(&mint_zkbin)?;
         let mint_circuit = ZkCircuit::new(empty_witnesses(&mint_zkbin), &mint_zkbin);
 
@@ -246,9 +245,9 @@ impl Faucetd {
         let burn_circuit = ZkCircuit::new(empty_witnesses(&burn_zkbin), &burn_zkbin);
 
         info!("Creating mint circuit proving key");
-        let mint_provingkey = ProvingKey::build(k, &mint_circuit);
+        let mint_provingkey = ProvingKey::build(mint_zkbin.k, &mint_circuit);
         info!("Creating burn circuit proving key");
-        let burn_provingkey = ProvingKey::build(k, &burn_circuit);
+        let burn_provingkey = ProvingKey::build(burn_zkbin.k, &burn_circuit);
 
         {
             let provingkeys = vec![

example/zk-inclusion-proof.rs

@@ -68,7 +68,7 @@ fn main() -> Result<()> {
     // ======
     // Bigger k = more rows, but slower circuit
     // Number of rows is 2^k
-    let k = 11;
+    let k = zkbin.k;
     println!("k = {}", k);
 
     // Witness values

example/zk.rs

@@ -47,7 +47,7 @@ fn main() -> Result<()> {
     // ======
     // Bigger k = more rows, but slower circuit
     // Number of rows is 2^k
-    let k = 13;
+    let k = zkbin.k;
 
     // Witness values
     let value = 42;

src/contract/test-harness/src/vks.rs

@@ -143,12 +143,12 @@ pub fn read_or_gen_vks_and_pks() -> Result<(Pks, Vks)> {
         debug!("Building VK for {}", zkbin.namespace);
         let witnesses = empty_witnesses(&zkbin);
         let circuit = ZkCircuit::new(witnesses, &zkbin);
-        let vk = VerifyingKey::build(13, &circuit);
+        let vk = VerifyingKey::build(zkbin.k, &circuit);
         let mut vk_buf = vec![];
         vk.write(&mut vk_buf)?;
         vks.push((bincode.to_vec(), zkbin.namespace.clone(), vk_buf));
 
-        let pk = ProvingKey::build(13, &circuit);
+        let pk = ProvingKey::build(zkbin.k, &circuit);
         let mut pk_buf = vec![];
         pk.write(&mut pk_buf)?;
         pks.push((bincode.to_vec(), zkbin.namespace, pk_buf));

src/runtime/import/db.rs

@@ -90,7 +90,7 @@ pub(crate) fn db_init(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u32) -> i
         }
     };
 
-    // Disabled until cursor_remaining feature is available on master.
+    // TODO: Disabled until cursor_remaining feature is available on master.
     // Then enable #![feature(cursor_remaining)] in src/lib.rs
     /*if !buf_reader.is_empty() {
         error!(target: "runtime::db::db_init()", "Trailing bytes in argument stream");
@@ -177,7 +177,7 @@ pub(crate) fn db_lookup(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u32) ->
         return CALLER_ACCESS_DENIED
     }
 
-    // Disabled until cursor_remaining feature is available on master.
+    // TODO: Disabled until cursor_remaining feature is available on master.
     // Then enable #![feature(cursor_remaining)] in src/lib.rs
     /*if !buf_reader.is_empty() {
         error!(target: "runtime::db::db_lookup()", "Trailing bytes in argument stream");
@@ -249,7 +249,7 @@ pub(crate) fn db_set(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u32) -> i3
     };
 
     // Disabled until cursor_remaining feature is available on master.
-    // Then enable #![feature(cursor_remaining)] in src/lib.rs
+    // TODO: Then enable #![feature(cursor_remaining)] in src/lib.rs
     /*if !buf_reader.is_empty() {
         error!(target: "runtime::db::db_set()", "Trailing bytes in argument stream");
         return DB_DEL_FAILED
@@ -331,7 +331,7 @@ pub(crate) fn db_del(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u32) -> i3
         }
     };
 
-    // Disabled until cursor_remaining feature is available on master.
+    // TODO: Disabled until cursor_remaining feature is available on master.
     // Then enable #![feature(cursor_remaining)] in src/lib.rs
     /*if !buf_reader.is_empty() {
         error!(target: "runtime::db::db_del()", "Trailing bytes in argument stream");
@@ -407,7 +407,7 @@ pub(crate) fn db_get(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u32) -> i6
         }
     };
 
-    // Disabled until cursor_remaining feature is available on master.
+    // TODO: Disabled until cursor_remaining feature is available on master.
     // Then enable #![feature(cursor_remaining)] in src/lib.rs
     /*if !buf_reader.is_empty() {
         error!(target: "runtime::db::db_get()", "Trailing bytes in argument stream");
@@ -490,7 +490,7 @@ pub(crate) fn db_contains_key(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u
         }
     };
 
-    // Disabled until cursor_remaining feature is available on master.
+    // TODO: Disabled until cursor_remaining feature is available on master.
     // Then enable #![feature(cursor_remaining)] in src/lib.rs
     /*if !buf_reader.is_empty() {
         error!(target: "runtime::db::db_contains_key()", "Trailing bytes in argument stream");
@@ -599,7 +599,7 @@ pub(crate) fn zkas_db_set(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u32)
     // We didn't find any existing bincode, so let's create a new VerifyingKey and write it all.
     info!(target: "runtime::db::zkas_db_set()", "Creating VerifyingKey for {} zkas circuit", zkbin.namespace);
     let circuit = ZkCircuit::new(empty_witnesses(&zkbin), &zkbin);
-    let vk = VerifyingKey::build(13, &circuit);
+    let vk = VerifyingKey::build(zkbin.k, &circuit);
     let mut vk_buf = vec![];
     if let Err(e) = vk.write(&mut vk_buf) {
         error!(target: "runtime::db::zkas_db_set()", "Failed to serialize VerifyingKey: {}", e);

tests/consensus_prop.rs

@@ -148,14 +148,14 @@ fn consensus_prop() -> Result<()> {
     ];
 
     let prover_circuit = ZkCircuit::new(prover_witnesses, &zkbin);
-    let mockprover = MockProver::run(13, &prover_circuit, vec![public_inputs.clone()])?;
+    let mockprover = MockProver::run(zkbin.k, &prover_circuit, vec![public_inputs.clone()])?;
     mockprover.assert_satisfied();
 
     let verifier_witnesses = empty_witnesses(&zkbin);
     let circuit = ZkCircuit::new(verifier_witnesses, &zkbin);
 
-    let proving_key = ProvingKey::build(13, &circuit);
-    let verifying_key = VerifyingKey::build(13, &circuit);
+    let proving_key = ProvingKey::build(zkbin.k, &circuit);
+    let verifying_key = VerifyingKey::build(zkbin.k, &circuit);
 
     let proof = Proof::create(&proving_key, &[prover_circuit], &public_inputs, &mut OsRng)?;
     proof.verify(&verifying_key, &public_inputs)?;

tests/halo2_vk_ser.rs

@@ -51,11 +51,11 @@ fn halo2_vk_ser() -> Result<()> {
 
     println!("Building vk1");
     let circuit = ZkCircuit::new(verifier_witnesses.clone(), &zkbin);
-    let vk1 = VerifyingKey::build(13, &circuit);
+    let vk1 = VerifyingKey::build(zkbin.k, &circuit);
 
     println!("Building vk2");
     let circuit = ZkCircuit::new(verifier_witnesses.clone(), &zkbin);
-    let vk2 = VerifyingKey::build(13, &circuit);
+    let vk2 = VerifyingKey::build(zkbin.k, &circuit);
 
     let mut buf1 = vec![];
     let mut buf2 = vec![];
@@ -84,7 +84,7 @@ fn halo2_vk_ser() -> Result<()> {
     // Now let's see if we can verify a proof with all four keys.
     println!("Creating pk");
     let circuit = ZkCircuit::new(verifier_witnesses.clone(), &zkbin);
-    let pk = ProvingKey::build(13, &circuit);
+    let pk = ProvingKey::build(zkbin.k, &circuit);
 
     let value = 666_u64;
     let value_blind = pallas::Scalar::random(&mut OsRng);

tests/zkvm_opcodes.rs

@@ -119,15 +119,15 @@ fn zkvm_opcodes() -> Result<()> {
 
     let circuit = ZkCircuit::new(prover_witnesses, &zkbin);
 
-    let mockprover = MockProver::run(13, &circuit, vec![public_inputs.clone()])?;
+    let mockprover = MockProver::run(zkbin.k, &circuit, vec![public_inputs.clone()])?;
     mockprover.assert_satisfied();
 
-    let proving_key = ProvingKey::build(13, &circuit);
+    let proving_key = ProvingKey::build(zkbin.k, &circuit);
     let proof = Proof::create(&proving_key, &[circuit], &public_inputs, &mut OsRng)?;
 
     let verifier_witnesses = empty_witnesses(&zkbin);
     let circuit = ZkCircuit::new(verifier_witnesses, &zkbin);
-    let verifying_key = VerifyingKey::build(13, &circuit);
+    let verifying_key = VerifyingKey::build(zkbin.k, &circuit);
     proof.verify(&verifying_key, &public_inputs)?;
 
     Ok(())