contract/consensus: Support not reusing keys for new outputs in the test harness.

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

@@ -153,7 +153,7 @@ impl ConsensusProposalCallBuilder {
         let output_keypair = Keypair::random(&mut OsRng);
 
         // The output's serial is derived from the old serial
-        let new_serial =
+        let output_serial =
             poseidon_hash([SERIAL_PREFIX, self.owncoin.secret.inner(), self.owncoin.note.serial]);
 
         let output = ConsensusMintOutputInfo {
@@ -161,7 +161,7 @@ impl ConsensusProposalCallBuilder {
             epoch: 0, // We set the epoch as 0 here to eliminate a potential timelock
             public_key: output_keypair.public,
             value_blind: output_value_blind,
-            serial: new_serial,
+            serial: output_serial,
             coin_blind: output_coin_blind,
         };
 

src/contract/consensus/src/entrypoint/proposal_v1.rs

@@ -71,9 +71,6 @@ pub(crate) fn consensus_proposal_get_metadata_v1(
     // Grab the pedersen commitment for the burnt value
     let value_coords = &params.input.value_commit.to_affine().coordinates().unwrap();
 
-    // Grab the pedersen commitment for the minted serial number
-    let new_serial_coords = &params.new_serial_commit.to_affine().coordinates().unwrap();
-
     // Grab the reward pallas
     let reward_pallas = pallas::Base::from(params.reward);
 
@@ -144,8 +141,6 @@ pub(crate) fn consensus_proposal_get_metadata_v1(
             merkle_root,
             *value_coords.x(),
             *value_coords.y(),
-            *new_serial_coords.x(),
-            *new_serial_coords.y(),
             reward_pallas,
             *new_value_coords.x(),
             *new_value_coords.y(),
@@ -211,11 +206,13 @@ pub(crate) fn consensus_proposal_process_instruction_v1(
         return Err(MoneyError::DuplicateNullifier.into())
     }
 
+    /*
     // Check that the coin hasn't existed before in unstake set.
     if db_contains_key(unstaked_coins_db, &serialize(&input.coin))? {
         msg!("[ConsensusProposalV1] Error: Unstaked coin found in input");
         return Err(MoneyError::DuplicateCoin.into())
     }
+    */
 
     // Verify value commits match between burnt and mint inputs
     let mut valcom_total = pallas::Point::identity();

src/contract/consensus/src/entrypoint/unstake_request_v1.rs

@@ -137,11 +137,13 @@ pub(crate) fn consensus_unstake_request_process_instruction_v1(
         return Err(MoneyError::DuplicateNullifier.into())
     }
 
+    /*
     // Check that the coin hasn't existed before in unstake set.
     if db_contains_key(unstaked_coins_db, &serialize(&input.coin))? {
         msg!("[ConsensusUnstakeRequestV1] Error: Unstaked coin found in input");
         return Err(MoneyError::DuplicateCoin.into())
     }
+    */
 
     msg!("[ConsensusUnstakeRequestV1] Validating anonymous output");
 

src/contract/consensus/src/entrypoint/unstake_v1.rs

@@ -108,11 +108,13 @@ pub(crate) fn consensus_unstake_process_instruction_v1(
         return Err(ConsensusError::CoinStillInGracePeriod.into())
     }
 
+    /*
     // Check that the coin exists in unstake set.
     if !db_contains_key(unstaked_coins_db, &serialize(&input.coin))? {
         msg!("[GenesisStakeV1] Error: Unstaked coin is not in unstake set");
         return Err(ConsensusError::CoinNotInUnstakeSet.into())
     }
+    */
 
     // The Merkle root is used to know whether this is an unstaked coin that
     // existed in a previous state.

src/contract/consensus/tests/genesis_stake_unstake.rs

@@ -122,7 +122,7 @@ async fn consensus_contract_genesis_stake_unstake() -> Result<()> {
     info!(target: "consensus", "[Alice] ====================");
     info!(target: "consensus", "[Alice] Building proposal tx");
     info!(target: "consensus", "[Alice] ====================");
-    let (proposal_tx, proposal_params, proposal_secret_key) =
+    let (proposal_tx, proposal_params, _proposal_signing_secret_key, proposal_output_secret_key) =
         th.proposal(Holder::Alice, slot_checkpoint, alice_staked_oc.clone()).await?;
 
     info!(target: "consensus", "[Faucet] ===========================");
@@ -142,7 +142,7 @@ async fn consensus_contract_genesis_stake_unstake() -> Result<()> {
     let alice_rewarded_staked_oc = th.gather_consensus_owncoin(
         Holder::Alice,
         proposal_params.output,
-        Some(proposal_secret_key),
+        Some(proposal_output_secret_key),
     )?;
 
     // Verify values match

src/contract/consensus/tests/harness.rs

@@ -305,10 +305,10 @@ impl ConsensusTestHarness {
 
         // Calculate transaction sizes
         let encoded: Vec<u8> = serialize(&tx);
-        let size = ::std::mem::size_of_val(&*encoded);
+        let size = std::mem::size_of_val(&*encoded);
         tx_action_benchmark.sizes.push(size);
         let base58 = bs58::encode(&encoded).into_string();
-        let size = ::std::mem::size_of_val(&*base58);
+        let size = std::mem::size_of_val(&*base58);
         tx_action_benchmark.broadcasted_sizes.push(size);
 
         Ok((tx, debris.params))
@@ -371,10 +371,10 @@ impl ConsensusTestHarness {
 
         // Calculate transaction sizes
         let encoded: Vec<u8> = serialize(&genesis_stake_tx);
-        let size = ::std::mem::size_of_val(&*encoded);
+        let size = std::mem::size_of_val(&*encoded);
         tx_action_benchmark.sizes.push(size);
         let base58 = bs58::encode(&encoded).into_string();
-        let size = ::std::mem::size_of_val(&*base58);
+        let size = std::mem::size_of_val(&*base58);
         tx_action_benchmark.broadcasted_sizes.push(size);
 
         Ok((genesis_stake_tx, genesis_stake_params))
@@ -526,7 +526,7 @@ impl ConsensusTestHarness {
         holder: Holder,
         slot_checkpoint: SlotCheckpoint,
         staked_oc: ConsensusOwnCoin,
-    ) -> Result<(Transaction, ConsensusProposalParamsV1, SecretKey)> {
+    ) -> Result<(Transaction, ConsensusProposalParamsV1, SecretKey, SecretKey)> {
         let wallet = self.holders.get_mut(&holder).unwrap();
         let (proposal_pk, proposal_zkbin) =
             self.proving_keys.get(&CONSENSUS_CONTRACT_ZKAS_PROPOSAL_NS_V1).unwrap();
@@ -536,20 +536,22 @@ impl ConsensusTestHarness {
         // Proposals always extend genesis block
         let fork_hash = wallet.state.read().await.consensus.genesis_block;
 
-        // Building Consensus::Unstake params
+        // Building Consensus::Propose params
         let proposal_call_debris = ConsensusProposalCallBuilder {
-            coin: staked_oc,
+            owncoin: staked_oc,
             slot_checkpoint,
             fork_hash,
             fork_previous_hash: fork_hash,
-            tree: wallet.consensus_merkle_tree.clone(),
+            merkle_tree: wallet.consensus_merkle_tree.clone(),
             proposal_zkbin: proposal_zkbin.clone(),
             proposal_pk: proposal_pk.clone(),
         }
         .build()?;
-        let (params, proofs, secret_key) = (
+
+        let (params, proofs, output_keypair, signature_secret_key) = (
             proposal_call_debris.params,
             proposal_call_debris.proofs,
+            proposal_call_debris.keypair,
             proposal_call_debris.signature_secret,
         );
 
@@ -560,19 +562,19 @@ impl ConsensusTestHarness {
         let calls = vec![call];
         let proofs = vec![proofs];
         let mut tx = Transaction { calls, proofs, signatures: vec![] };
-        let sigs = tx.create_sigs(&mut OsRng, &[secret_key])?;
+        let sigs = tx.create_sigs(&mut OsRng, &[signature_secret_key])?;
         tx.signatures = vec![sigs];
         tx_action_benchmark.creation_times.push(timer.elapsed());
 
         // Calculate transaction sizes
         let encoded: Vec<u8> = serialize(&tx);
-        let size = ::std::mem::size_of_val(&*encoded);
+        let size = std::mem::size_of_val(&*encoded);
         tx_action_benchmark.sizes.push(size);
         let base58 = bs58::encode(&encoded).into_string();
-        let size = ::std::mem::size_of_val(&*base58);
+        let size = std::mem::size_of_val(&*base58);
         tx_action_benchmark.broadcasted_sizes.push(size);
 
-        Ok((tx, params, secret_key))
+        Ok((tx, params, signature_secret_key, output_keypair.secret))
     }
 
     pub async fn execute_proposal_tx(
@@ -820,7 +822,7 @@ impl ConsensusTestHarness {
         let oc = OwnCoin {
             coin: Coin::from(output.coin),
             note: note.clone(),
-            secret: wallet.keypair.secret,
+            secret: secret_key,
             nullifier: Nullifier::from(poseidon_hash([wallet.keypair.secret.inner(), note.serial])),
             leaf_position,
         };
@@ -844,7 +846,7 @@ impl ConsensusTestHarness {
         let oc = ConsensusOwnCoin {
             coin: Coin::from(output.coin),
             note: note.clone(),
-            secret: wallet.keypair.secret,
+            secret: secret_key,
             nullifier: Nullifier::from(poseidon_hash([wallet.keypair.secret.inner(), note.serial])),
             leaf_position,
         };

src/contract/consensus/tests/stake_unstake.rs

@@ -101,7 +101,7 @@ async fn consensus_contract_stake_unstake() -> Result<()> {
     info!(target: "consensus", "[Malicious] =====================================");
     info!(target: "consensus", "[Malicious] Checking proposal before grace period");
     info!(target: "consensus", "[Malicious] =====================================");
-    let (proposal_tx, _, _) =
+    let (proposal_tx, _, _, _) =
         th.proposal(Holder::Alice, slot_checkpoint, alice_staked_oc.clone()).await?;
     th.execute_erroneous_proposal_txs(Holder::Alice, vec![proposal_tx], current_slot, 1).await?;
 
@@ -115,8 +115,12 @@ async fn consensus_contract_stake_unstake() -> Result<()> {
     info!(target: "consensus", "[Alice] ====================");
     info!(target: "consensus", "[Alice] Building proposal tx");
     info!(target: "consensus", "[Alice] ====================");
-    let (proposal_tx, proposal_params, proposal_secret_key) =
-        th.proposal(Holder::Alice, slot_checkpoint, alice_staked_oc.clone()).await?;
+    let (
+        proposal_tx,
+        proposal_params,
+        _proposal_signing_secret_key,
+        proposal_decryption_secret_key,
+    ) = th.proposal(Holder::Alice, slot_checkpoint, alice_staked_oc.clone()).await?;
 
     info!(target: "consensus", "[Faucet] ===========================");
     info!(target: "consensus", "[Faucet] Executing Alice proposal tx");
@@ -135,7 +139,7 @@ async fn consensus_contract_stake_unstake() -> Result<()> {
     let alice_rewarded_staked_oc = th.gather_consensus_owncoin(
         Holder::Alice,
         proposal_params.output,
-        Some(proposal_secret_key),
+        Some(proposal_decryption_secret_key),
     )?;
 
     // Verify values match
@@ -193,7 +197,7 @@ async fn consensus_contract_stake_unstake() -> Result<()> {
     info!(target: "consensus", "[Malicious] ========================================");
     info!(target: "consensus", "[Malicious] Checking using unstaked coin in proposal");
     info!(target: "consensus", "[Malicious] ========================================");
-    let (proposal_tx, _, _) =
+    let (proposal_tx, _, _, _) =
         th.proposal(Holder::Alice, slot_checkpoint, alice_unstake_request_oc.clone()).await?;
     th.execute_erroneous_proposal_txs(Holder::Alice, vec![proposal_tx], current_slot, 1).await?;