zk: Pass a ZkBinary reference to ZkCircuit::new instead of cloning.

bin/drk/src/rpc_dao.rs

@@ -75,8 +75,7 @@ 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.clone());
+        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);
 
@@ -166,9 +165,9 @@ impl Drk {
 
         let k = 13;
         let propose_burn_circuit =
-            ZkCircuit::new(empty_witnesses(&propose_burn_zkbin), propose_burn_zkbin.clone());
+            ZkCircuit::new(empty_witnesses(&propose_burn_zkbin), &propose_burn_zkbin);
         let propose_main_circuit =
-            ZkCircuit::new(empty_witnesses(&propose_main_zkbin), propose_main_zkbin.clone());
+            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);
@@ -351,9 +350,9 @@ impl Drk {
 
         let k = 13;
         let dao_vote_burn_circuit =
-            ZkCircuit::new(empty_witnesses(&dao_vote_burn_zkbin), dao_vote_burn_zkbin.clone());
+            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.clone());
+            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);
@@ -419,8 +418,8 @@ 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.clone());
-        let burn_circuit = ZkCircuit::new(empty_witnesses(&burn_zkbin), burn_zkbin.clone());
+        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);
         eprintln!("Creating Money Burn circuit proving key");
@@ -458,7 +457,7 @@ impl Drk {
             return Err(anyhow!("DAO Exec circuit not found"))
         };
         let exec_zkbin = ZkBinary::decode(&exec_zkbin.1)?;
-        let exec_circuit = ZkCircuit::new(empty_witnesses(&exec_zkbin), exec_zkbin.clone());
+        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);
 

bin/drk/src/rpc_swap.rs

@@ -124,8 +124,8 @@ impl Drk {
         let burn_zkbin = ZkBinary::decode(&burn_zkbin.1)?;
 
         let k = 13;
-        let mint_circuit = ZkCircuit::new(empty_witnesses(&mint_zkbin), mint_zkbin.clone());
-        let burn_circuit = ZkCircuit::new(empty_witnesses(&burn_zkbin), burn_zkbin.clone());
+        let mint_circuit = ZkCircuit::new(empty_witnesses(&mint_zkbin), &mint_zkbin);
+        let burn_circuit = ZkCircuit::new(empty_witnesses(&burn_zkbin), &burn_zkbin);
 
         // Since we're creating the first half, we generate the blinds.
         let value_blinds = [pallas::Scalar::random(&mut OsRng), pallas::Scalar::random(&mut OsRng)];
@@ -216,8 +216,8 @@ impl Drk {
         let burn_zkbin = ZkBinary::decode(&burn_zkbin.1)?;
 
         let k = 13;
-        let mint_circuit = ZkCircuit::new(empty_witnesses(&mint_zkbin), mint_zkbin.clone());
-        let burn_circuit = ZkCircuit::new(empty_witnesses(&burn_zkbin), burn_zkbin.clone());
+        let mint_circuit = ZkCircuit::new(empty_witnesses(&mint_zkbin), &mint_zkbin);
+        let burn_circuit = ZkCircuit::new(empty_witnesses(&burn_zkbin), &burn_zkbin);
 
         // TODO: Maybe some kind of verification at this point
 

bin/drk/src/rpc_token.rs

@@ -77,7 +77,7 @@ impl Drk {
         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.clone());
+            ZkCircuit::new(empty_witnesses(&token_mint_zkbin), &token_mint_zkbin);
 
         eprintln!("Creating token mint circuit proving keys");
         let mint_builder = TokenMintCallBuilder {
@@ -130,7 +130,7 @@ impl Drk {
         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.clone());
+            ZkCircuit::new(empty_witnesses(&token_freeze_zkbin), &token_freeze_zkbin);
 
         eprintln!("Creating token freeze circuit proving keys");
         let freeze_builder = TokenFreezeCallBuilder {

bin/drk/src/rpc_transfer.rs

@@ -124,8 +124,8 @@ impl Drk {
         let burn_zkbin = ZkBinary::decode(&burn_zkbin.1)?;
 
         let k = 13;
-        let mint_circuit = ZkCircuit::new(empty_witnesses(&mint_zkbin), mint_zkbin.clone());
-        let burn_circuit = ZkCircuit::new(empty_witnesses(&burn_zkbin), burn_zkbin.clone());
+        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 transfer_builder = TransferCallBuilder {

bin/faucetd/src/main.rs

@@ -240,10 +240,10 @@ impl Faucetd {
 
         let k = 13;
         let mint_zkbin = ZkBinary::decode(&mint_zkbin)?;
-        let mint_circuit = ZkCircuit::new(empty_witnesses(&mint_zkbin), mint_zkbin.clone());
+        let mint_circuit = ZkCircuit::new(empty_witnesses(&mint_zkbin), &mint_zkbin);
 
         let burn_zkbin = ZkBinary::decode(&burn_zkbin)?;
-        let burn_circuit = ZkCircuit::new(empty_witnesses(&burn_zkbin), burn_zkbin.clone());
+        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);

src/blockchain/contract_store.rs

@@ -24,7 +24,7 @@ use log::{debug, error};
 
 use crate::{
     runtime::vm_runtime::SMART_CONTRACT_ZKAS_DB_NAME,
-    zk::{VerifyingKey, ZkCircuit},
+    zk::{empty_witnesses, VerifyingKey, ZkCircuit},
     zkas::ZkBinary,
     Error, Result,
 };
@@ -210,9 +210,12 @@ impl ContractStateStore {
         // The first vec is the compiled zkas binary
         let zkbin = ZkBinary::decode(&zkbin).unwrap();
 
+        // Construct the circuit to be able to read the VerifyingKey
+        let circuit = ZkCircuit::new(empty_witnesses(&zkbin), &zkbin);
+
         // The second one is the serialized VerifyingKey for it
         let mut vk_buf = Cursor::new(vkbin);
-        let vk = VerifyingKey::read::<Cursor<Vec<u8>>, ZkCircuit>(&mut vk_buf).unwrap();
+        let vk = VerifyingKey::read::<Cursor<Vec<u8>>, ZkCircuit>(&mut vk_buf, circuit).unwrap();
 
         Ok((zkbin, vk))
     }
@@ -319,9 +322,12 @@ impl ContractStateStoreOverlay {
         // The first vec is the compiled zkas binary
         let zkbin = ZkBinary::decode(&zkbin).unwrap();
 
+        // Construct the circuit to be able to read the VerifyingKey
+        let circuit = ZkCircuit::new(empty_witnesses(&zkbin), &zkbin);
+
         // The second one is the serialized VerifyingKey for it
         let mut vk_buf = Cursor::new(vkbin);
-        let vk = VerifyingKey::read::<Cursor<Vec<u8>>, ZkCircuit>(&mut vk_buf).unwrap();
+        let vk = VerifyingKey::read::<Cursor<Vec<u8>>, ZkCircuit>(&mut vk_buf, circuit).unwrap();
 
         Ok((zkbin, vk))
     }

src/consensus/lead_coin.rs

@@ -362,7 +362,7 @@ impl LeadCoin {
             Witness::Base(Value::known(sigma2)),
             Witness::Base(Value::known(headstart)),
         ];
-        let circuit = ZkCircuit::new(witnesses, zkbin);
+        let circuit = ZkCircuit::new(witnesses, &zkbin);
         let public_inputs = self.public_inputs(sigma1, sigma2, eta, slot, derived_blind);
         (Ok(Proof::create(pk, &[circuit], &public_inputs, &mut OsRng).unwrap()), public_inputs)
     }
@@ -416,7 +416,7 @@ impl LeadCoin {
             Witness::Scalar(Value::known(transfered_coin.opening)),
             Witness::Base(Value::known(xferval)),
         ];
-        let circuit = ZkCircuit::new(witnesses, zkbin);
+        let circuit = ZkCircuit::new(witnesses, &zkbin);
         let proof = Proof::create(
             pk,
             &[circuit],

src/consensus/validator.rs

@@ -110,8 +110,7 @@ impl ValidatorState {
         debug!(target: "consensus::validator", "Generating leader proof keys with k: {}", constants::LEADER_PROOF_K);
         let bincode = include_bytes!("../../proof/lead.zk.bin");
         let zkbin = ZkBinary::decode(bincode)?;
-        let witnesses = empty_witnesses(&zkbin);
-        let circuit = ZkCircuit::new(witnesses, zkbin);
+        let circuit = ZkCircuit::new(empty_witnesses(&zkbin), &zkbin);
 
         let lead_verifying_key = VerifyingKey::build(constants::LEADER_PROOF_K, &circuit);
         // We only need this proving key if we're going to participate in the consensus.

src/contract/consensus/src/client/common.rs

@@ -91,7 +91,7 @@ pub fn create_consensus_mint_proof(
         Witness::Scalar(Value::known(output.value_blind)),
     ];
 
-    let circuit = ZkCircuit::new(prover_witnesses, zkbin.clone());
+    let circuit = ZkCircuit::new(prover_witnesses, &zkbin);
     let proof = Proof::create(pk, &[circuit], &public_inputs.to_vec(), &mut OsRng)?;
 
     Ok((proof, public_inputs))
@@ -172,7 +172,7 @@ pub fn create_consensus_burn_proof(
         Witness::MerklePath(Value::known(input.merkle_path.clone().try_into().unwrap())),
     ];
 
-    let circuit = ZkCircuit::new(prover_witnesses, zkbin.clone());
+    let circuit = ZkCircuit::new(prover_witnesses, &zkbin);
     let proof = Proof::create(pk, &[circuit], &public_inputs.to_vec(), &mut OsRng)?;
 
     Ok((proof, public_inputs, input.secret))

src/contract/consensus/src/client/proposal_v1.rs

@@ -267,6 +267,7 @@ fn create_proposal_proof(
         slot.sigma1 * value_pallas + slot.sigma2 * value_pallas * value_pallas + HEADSTART;
 
     if y >= shifted_target {
+        error!("MU_Y: {:?}", mu_y);
         error!("Y: {:?}", y);
         error!("TARGET: {:?}", shifted_target);
         return Err(CoinIsNotSlotProducer)
@@ -351,7 +352,7 @@ fn create_proposal_proof(
         Witness::Base(Value::known(public_inputs.headstart)),
     ];
 
-    let circuit = ZkCircuit::new(prover_witnesses, zkbin.clone());
+    let circuit = ZkCircuit::new(prover_witnesses, &zkbin);
     let proof = Proof::create(pk, &[circuit], &public_inputs.to_vec(), &mut OsRng)?;
 
     Ok((proof, public_inputs))

src/contract/dao/src/client/exec.rs

@@ -171,7 +171,7 @@ impl DaoExecCall {
             user_data,
         ];
 
-        let circuit = ZkCircuit::new(prover_witnesses, exec_zkbin.clone());
+        let circuit = ZkCircuit::new(prover_witnesses, &exec_zkbin);
         let input_proof = Proof::create(exec_pk, &[circuit], &public_inputs, &mut OsRng)
             .expect("DAO::exec() proving error!)");
         proofs.push(input_proof);

src/contract/dao/src/client/mint.rs

@@ -80,7 +80,7 @@ pub fn make_mint_call(
 
     let public = vec![pub_x, pub_y, dao_bulla];
 
-    let circuit = ZkCircuit::new(prover_witnesses, dao_mint_zkbin.clone());
+    let circuit = ZkCircuit::new(prover_witnesses, &dao_mint_zkbin);
     let proof = Proof::create(dao_mint_pk, &[circuit], &public, &mut OsRng)?;
 
     let dao_mint_params = DaoMintParams { dao_bulla: dao_bulla.into(), dao_pubkey: dao.public_key };

src/contract/dao/src/client/propose.rs

@@ -154,7 +154,7 @@ impl DaoProposeCall {
                 sig_x,
                 sig_y,
             ];
-            let circuit = ZkCircuit::new(prover_witnesses, burn_zkbin.clone());
+            let circuit = ZkCircuit::new(prover_witnesses, &burn_zkbin);
 
             let proving_key = &burn_pk;
             let input_proof = Proof::create(proving_key, &[circuit], &public_inputs, &mut OsRng)
@@ -235,7 +235,7 @@ impl DaoProposeCall {
             *total_funds_coords.x(),
             *total_funds_coords.y(),
         ];
-        let circuit = ZkCircuit::new(prover_witnesses, main_zkbin.clone());
+        let circuit = ZkCircuit::new(prover_witnesses, &main_zkbin);
 
         let main_proof = Proof::create(main_pk, &[circuit], &public_inputs, &mut OsRng)
             .expect("DAO::propose() proving error!");

src/contract/dao/src/client/vote.rs

@@ -157,7 +157,7 @@ impl DaoVoteCall {
                 sig_y,
             ];
 
-            let circuit = ZkCircuit::new(prover_witnesses, burn_zkbin.clone());
+            let circuit = ZkCircuit::new(prover_witnesses, &burn_zkbin);
             debug!(target: "dao", "input_proof Proof::create()");
             let input_proof = Proof::create(burn_pk, &[circuit], &public_inputs, &mut OsRng)
                 .expect("DAO::vote() proving error!");
@@ -251,7 +251,7 @@ impl DaoVoteCall {
             *all_vote_commit_coords.y(),
         ];
 
-        let circuit = ZkCircuit::new(prover_witnesses, main_zkbin.clone());
+        let circuit = ZkCircuit::new(prover_witnesses, &main_zkbin);
 
         debug!(target: "dao", "main_proof = Proof::create()");
         let main_proof = Proof::create(main_pk, &[circuit], &public_inputs, &mut OsRng)

src/contract/money/src/client/stake_v1.rs

@@ -221,7 +221,7 @@ pub fn create_stake_burn_proof(
         Witness::Base(Value::known(signature_secret.inner())),
     ];
 
-    let circuit = ZkCircuit::new(prover_witnesses, zkbin.clone());
+    let circuit = ZkCircuit::new(prover_witnesses, &zkbin);
     let proof = Proof::create(pk, &[circuit], &public_inputs.to_vec(), &mut OsRng)?;
 
     Ok((proof, public_inputs))

src/contract/money/src/client/token_freeze_v1.rs

@@ -87,7 +87,7 @@ pub(crate) fn create_token_freeze_proof(
 
     let prover_witnesses = vec![Witness::Base(Value::known(mint_authority.secret.inner()))];
 
-    let circuit = ZkCircuit::new(prover_witnesses, zkbin.clone());
+    let circuit = ZkCircuit::new(prover_witnesses, &zkbin);
     let proof = Proof::create(pk, &[circuit], &public_inputs.to_vec(), &mut OsRng)?;
 
     Ok((proof, public_inputs))

src/contract/money/src/client/token_mint_v1.rs

@@ -217,7 +217,7 @@ pub fn create_token_mint_proof(
         Witness::Scalar(Value::known(token_blind)),
     ];
 
-    let circuit = ZkCircuit::new(prover_witnesses, zkbin.clone());
+    let circuit = ZkCircuit::new(prover_witnesses, &zkbin);
     let proof = Proof::create(pk, &[circuit], &public_inputs.to_vec(), &mut OsRng)?;
 
     Ok((proof, public_inputs))

src/contract/money/src/client/transfer_v1.rs

@@ -456,7 +456,7 @@ pub fn create_transfer_burn_proof(
         Witness::Base(Value::known(signature_secret.inner())),
     ];
 
-    let circuit = ZkCircuit::new(prover_witnesses, zkbin.clone());
+    let circuit = ZkCircuit::new(prover_witnesses, &zkbin);
     let proof = Proof::create(pk, &[circuit], &public_inputs.to_vec(), &mut OsRng)?;
 
     Ok((proof, public_inputs))
@@ -501,7 +501,7 @@ pub fn create_transfer_mint_proof(
         Witness::Scalar(Value::known(token_blind)),
     ];
 
-    let circuit = ZkCircuit::new(prover_witnesses, zkbin.clone());
+    let circuit = ZkCircuit::new(prover_witnesses, &zkbin);
     let proof = Proof::create(pk, &[circuit], &public_inputs.to_vec(), &mut OsRng)?;
 
     Ok((proof, public_inputs))

src/contract/money/src/client/unstake_v1.rs

@@ -200,7 +200,7 @@ pub fn create_unstake_mint_proof(
         Witness::Scalar(Value::known(token_blind)),
     ];
 
-    let circuit = ZkCircuit::new(prover_witnesses, zkbin.clone());
+    let circuit = ZkCircuit::new(prover_witnesses, &zkbin);
     let proof = Proof::create(pk, &[circuit], &public_inputs.to_vec(), &mut OsRng)?;
 
     Ok((proof, public_inputs))

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

@@ -255,7 +255,7 @@ impl TestHarness {
                 let (zkbin, _): (Vec<u8>, Vec<u8>) = deserialize(&zkas_bytes)?;
                 let zkbin = ZkBinary::decode(&zkbin)?;
                 let witnesses = empty_witnesses(&zkbin);
-                let circuit = ZkCircuit::new(witnesses, zkbin.clone());
+                let circuit = ZkCircuit::new(witnesses, &zkbin);
                 let pk = ProvingKey::build(13, &circuit);
                 proving_keys.insert($ns, (pk, zkbin));
             };

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

@@ -112,7 +112,7 @@ fn read_or_gen_vks() -> Result<Vks> {
         let zkbin = ZkBinary::decode(bincode)?;
         debug!("Building VK for {}", zkbin.namespace);
         let witnesses = empty_witnesses(&zkbin);
-        let circuit = ZkCircuit::new(witnesses, zkbin.clone());
+        let circuit = ZkCircuit::new(witnesses, &zkbin);
         let vk = VerifyingKey::build(13, &circuit);
         let mut vk_buf = vec![];
         vk.write(&mut vk_buf)?;

src/runtime/import/db.rs

@@ -598,8 +598,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 witnesses = empty_witnesses(&zkbin);
-    let circuit = ZkCircuit::new(witnesses, zkbin.clone());
+    let circuit = ZkCircuit::new(empty_witnesses(&zkbin), &zkbin);
     let vk = VerifyingKey::build(13, &circuit);
     let mut vk_buf = vec![];
     if let Err(e) = vk.write(&mut vk_buf) {

src/sdk/python/src/zk_circuit.rs

@@ -46,7 +46,7 @@ impl ZkCircuit {
 
     fn verifier_build(&self, circuit_code: &PyCell<ZkBinary>) -> Self {
         let circuit_code = circuit_code.borrow().deref().0.clone();
-        let circuit = vm::ZkCircuit::new(empty_witnesses(&circuit_code), circuit_code.clone());
+        let circuit = vm::ZkCircuit::new(empty_witnesses(&circuit_code), &circuit_code);
         Self(circuit, self.1.clone())
     }
 

tests/consensus_prop.rs

@@ -147,12 +147,12 @@ fn consensus_prop() -> Result<()> {
         HEADSTART,
     ];
 
-    let prover_circuit = ZkCircuit::new(prover_witnesses, zkbin.clone());
+    let prover_circuit = ZkCircuit::new(prover_witnesses, &zkbin);
     let mockprover = MockProver::run(13, &prover_circuit, vec![public_inputs.clone()])?;
     mockprover.assert_satisfied();
 
     let verifier_witnesses = empty_witnesses(&zkbin);
-    let circuit = ZkCircuit::new(verifier_witnesses, zkbin);
+    let circuit = ZkCircuit::new(verifier_witnesses, &zkbin);
 
     let proving_key = ProvingKey::build(13, &circuit);
     let verifying_key = VerifyingKey::build(13, &circuit);

tests/halo2_vk_ser.rs

@@ -50,11 +50,11 @@ fn halo2_vk_ser() -> Result<()> {
     let verifier_witnesses = empty_witnesses(&zkbin);
 
     println!("Building vk1");
-    let circuit = ZkCircuit::new(verifier_witnesses.clone(), zkbin.clone());
+    let circuit = ZkCircuit::new(verifier_witnesses.clone(), &zkbin);
     let vk1 = VerifyingKey::build(13, &circuit);
 
     println!("Building vk2");
-    let circuit = ZkCircuit::new(verifier_witnesses.clone(), zkbin.clone());
+    let circuit = ZkCircuit::new(verifier_witnesses.clone(), &zkbin);
     let vk2 = VerifyingKey::build(13, &circuit);
 
     let mut buf1 = vec![];
@@ -79,7 +79,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.clone());
+    let circuit = ZkCircuit::new(verifier_witnesses.clone(), &zkbin);
     let pk = ProvingKey::build(13, &circuit);
 
     let value = 666_u64;
@@ -151,7 +151,7 @@ fn halo2_vk_ser() -> Result<()> {
     ];
 
     println!("Creating proof");
-    let circuit = ZkCircuit::new(prover_witnesses, zkbin);
+    let circuit = ZkCircuit::new(prover_witnesses, &zkbin);
     let proof = Proof::create(&pk, &[circuit], &public_inputs, &mut OsRng)?;
 
     println!("Verifying with vk1");

tests/zkvm_opcodes.rs

@@ -117,7 +117,7 @@ fn zkvm_opcodes() -> Result<()> {
         pallas::Base::ZERO,
     ];
 
-    let circuit = ZkCircuit::new(prover_witnesses, zkbin.clone());
+    let circuit = ZkCircuit::new(prover_witnesses, &zkbin);
 
     let mockprover = MockProver::run(13, &circuit, vec![public_inputs.clone()])?;
     mockprover.assert_satisfied();
@@ -126,7 +126,7 @@ fn zkvm_opcodes() -> Result<()> {
     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 circuit = ZkCircuit::new(verifier_witnesses, &zkbin);
     let verifying_key = VerifyingKey::build(13, &circuit);
     proof.verify(&verifying_key, &public_inputs)?;