contract/consensus: constrain public key of nullifier' secret key, some naming cleanup

src/contract/consensus/proof/proposal_reward_v1.zk

@@ -39,6 +39,11 @@ circuit "ProposalReward_V1" {
 	nullifier = poseidon_hash(secret_key, serial);
 	constrain_instance(nullifier);
 
+	# Derive public key that will be used in VRF proof and constrain it
+	pub = ec_mul_base(secret_key, NULLIFIER_K);
+	constrain_instance(ec_get_x(pub));
+	constrain_instance(ec_get_y(pub));
+
 	# Pedersen commitment for coin's value
 	vcv = ec_mul_short(value, VALUE_COMMIT_VALUE);
 	vcr = ec_mul(value_blind, VALUE_COMMIT_RANDOM);

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

@@ -26,7 +26,7 @@ use darkfi::{
 };
 use darkfi_money_contract::{
     client::{MoneyNote, OwnCoin},
-    model::{ConsensusUnstakeParamsV1, Input, Output, StakeInput},
+    model::{Input, Output, StakeInput},
 };
 use darkfi_sdk::{
     crypto::{
@@ -46,23 +46,25 @@ use crate::{
         unstake_v1::{create_unstake_burn_proof, TransactionBuilderInputInfo as UnstakeTBII},
     },
     model::{
-        ConsensusProposalMintParamsV1, ConsensusProposalRewardParamsV1, HEADSTART, MU_RHO_PREFIX,
-        MU_Y_PREFIX, REWARD, REWARD_PALLAS, SEED_PREFIX, SERIAL_PREFIX, ZERO,
+        ConsensusProposalBurnParamsV1, ConsensusProposalMintParamsV1,
+        ConsensusProposalRewardParamsV1, HEADSTART, MU_RHO_PREFIX, MU_Y_PREFIX, REWARD,
+        REWARD_PALLAS, SEED_PREFIX, SERIAL_PREFIX, ZERO,
     },
 };
 
 pub struct ConsensusProposalCallDebris {
-    pub unstake_params: ConsensusUnstakeParamsV1,
-    pub unstake_proofs: Vec<Proof>,
+    pub burn_params: ConsensusProposalBurnParamsV1,
+    pub burn_proofs: Vec<Proof>,
     pub reward_params: ConsensusProposalRewardParamsV1,
     pub reward_proofs: Vec<Proof>,
-    pub stake_params: ConsensusProposalMintParamsV1,
-    pub stake_proofs: Vec<Proof>,
+    pub mint_params: ConsensusProposalMintParamsV1,
+    pub mint_proofs: Vec<Proof>,
     pub signature_secret: SecretKey,
 }
 
 pub struct ConsensusProposalRewardRevealed {
     pub nullifier: Nullifier,
+    pub public_key: PublicKey,
     pub value_commit: pallas::Point,
     pub new_serial_commit: pallas::Point,
     pub new_value_commit: pallas::Point,
@@ -76,6 +78,7 @@ pub struct ConsensusProposalRewardRevealed {
 
 impl ConsensusProposalRewardRevealed {
     pub fn to_vec(&self) -> Vec<pallas::Base> {
+        let (pub_x, pub_y) = self.public_key.xy();
         let value_coords = self.value_commit.to_affine().coordinates().unwrap();
         let new_serial_coords = self.new_serial_commit.to_affine().coordinates().unwrap();
         let new_value_coords = self.new_value_commit.to_affine().coordinates().unwrap();
@@ -84,6 +87,8 @@ impl ConsensusProposalRewardRevealed {
         // as the `constrain_instance` calls in the zkas code.
         vec![
             self.nullifier.inner(),
+            pub_x,
+            pub_y,
             *value_coords.x(),
             *value_coords.y(),
             *new_serial_coords.x(),
@@ -198,9 +203,12 @@ impl ConsensusProposalCallBuilder {
         };
 
         // We now fill this with necessary stuff
-        let unstake_params = ConsensusUnstakeParamsV1 { token_blind, input: input.clone() };
-        let unstake_proofs = vec![proof];
-        let unstake_input = input;
+        let burnt_secret_key = self.coin.secret.inner();
+        let public_key = PublicKey::from_secret(burnt_secret_key.into());
+        let burn_params =
+            ConsensusProposalBurnParamsV1 { token_blind, input: input.clone(), public_key };
+        let burn_proofs = vec![proof];
+        let burnt_input = input;
 
         debug!("Building Consensus::ProposalMintV1 contract call for proposal");
         let new_value = value + REWARD;
@@ -212,7 +220,6 @@ impl ConsensusProposalCallBuilder {
         let output = StakeTBOI { value: new_value, token_id, public_key: self.recipient };
         debug!("Finished building output for proposal");
 
-        let burnt_secret_key = self.coin.secret.inner();
         let burnt_serial = self.coin.note.serial;
         let spend_hook = CONSENSUS_CONTRACT_ID.inner();
         let user_data = pallas::Base::random(&mut OsRng);
@@ -266,13 +273,13 @@ impl ConsensusProposalCallBuilder {
 
         // We now fill this with necessary stuff
         let serial_commit = public_inputs.serial_commit;
-        let stake_params = ConsensusProposalMintParamsV1 {
+        let mint_params = ConsensusProposalMintParamsV1 {
             input: input.clone(),
             output: output.clone(),
             serial_commit,
         };
-        let stake_proofs = vec![proof];
-        let stake_input = input;
+        let mint_proofs = vec![proof];
+        let mint_input = input;
 
         debug!("Building Consensus::ProposalRewardV1 contract call for proposal");
         let secret_key = self.coin.secret.inner();
@@ -289,13 +296,15 @@ impl ConsensusProposalCallBuilder {
         )?;
 
         // We now fill this with necessary stuff
+        let burnt_public_key = public_inputs.public_key;
         let new_serial_commit = serial_commit;
         let slot = self.slot_checkpoint.slot;
         let y = public_inputs.y;
         let rho = public_inputs.rho;
         let reward_params = ConsensusProposalRewardParamsV1 {
-            unstake_input,
-            stake_input,
+            burnt_input,
+            burnt_public_key,
+            mint_input,
             output,
             new_serial_commit,
             slot,
@@ -307,12 +316,12 @@ impl ConsensusProposalCallBuilder {
         // Now we should have all the params, zk proofs and signature secret.
         // We return it all and let the caller deal with it.
         let debris = ConsensusProposalCallDebris {
-            unstake_params,
-            unstake_proofs,
+            burn_params,
+            burn_proofs,
             reward_params,
             reward_proofs,
-            stake_params,
-            stake_proofs,
+            mint_params,
+            mint_proofs,
             signature_secret,
         };
         Ok(debris)
@@ -331,6 +340,7 @@ pub fn create_proposal_reward_proof(
 ) -> Result<(Proof, ConsensusProposalRewardRevealed)> {
     // Proof parameters
     let nullifier = Nullifier::from(poseidon_hash([secret_key, serial]));
+    let public_key = PublicKey::from_secret(secret_key.into());
     let value_commit = pedersen_commitment_u64(value, value_blind);
     let new_serial = poseidon_hash([SERIAL_PREFIX, secret_key, serial, ZERO]);
     let new_serial_commit = pedersen_commitment_base(new_serial, new_serial_blind);
@@ -346,6 +356,7 @@ pub fn create_proposal_reward_proof(
     // Generate public inputs, witnesses and proof
     let public_inputs = ConsensusProposalRewardRevealed {
         nullifier,
+        public_key,
         value_commit,
         new_serial_commit,
         new_value_commit,

src/contract/consensus/src/entrypoint/proposal_burn_v1.rs

@@ -17,10 +17,8 @@
  */
 
 use darkfi_money_contract::{
-    error::MoneyError,
-    model::{ConsensusUnstakeParamsV1, ConsensusUnstakeUpdateV1},
-    CONSENSUS_CONTRACT_COIN_ROOTS_TREE, CONSENSUS_CONTRACT_NULLIFIERS_TREE,
-    MONEY_CONTRACT_ZKAS_BURN_NS_V1,
+    error::MoneyError, model::ConsensusUnstakeUpdateV1, CONSENSUS_CONTRACT_COIN_ROOTS_TREE,
+    CONSENSUS_CONTRACT_NULLIFIERS_TREE, MONEY_CONTRACT_ZKAS_BURN_NS_V1,
 };
 use darkfi_sdk::{
     crypto::{
@@ -36,7 +34,7 @@ use darkfi_sdk::{
 use darkfi_serial::{deserialize, serialize, Encodable, WriteExt};
 
 use crate::{
-    model::{ConsensusProposalRewardParamsV1, ZERO},
+    model::{ConsensusProposalBurnParamsV1, ConsensusProposalRewardParamsV1, ZERO},
     ConsensusFunction,
 };
 
@@ -47,7 +45,7 @@ pub(crate) fn consensus_proposal_burn_get_metadata_v1(
     calls: Vec<ContractCall>,
 ) -> Result<Vec<u8>, ContractError> {
     let self_ = &calls[call_idx as usize];
-    let params: ConsensusUnstakeParamsV1 = deserialize(&self_.data[1..])?;
+    let params: ConsensusProposalBurnParamsV1 = deserialize(&self_.data[1..])?;
 
     // Public inputs for the ZK proofs we have to verify
     let mut zk_public_inputs: Vec<(String, Vec<pallas::Base>)> = vec![];
@@ -96,7 +94,7 @@ pub(crate) fn consensus_proposal_burn_process_instruction_v1(
     calls: Vec<ContractCall>,
 ) -> Result<Vec<u8>, ContractError> {
     let self_ = &calls[call_idx as usize];
-    let params: ConsensusUnstakeParamsV1 = deserialize(&self_.data[1..])?;
+    let params: ConsensusProposalBurnParamsV1 = deserialize(&self_.data[1..])?;
 
     // Access the necessary databases where there is information to
     // validate this state transition.
@@ -161,7 +159,7 @@ pub(crate) fn consensus_proposal_burn_process_instruction_v1(
 
     // Verify next call StakeInput is the same as this calls input
     let next_params: ConsensusProposalRewardParamsV1 = deserialize(&next.data[1..])?;
-    if input != &next_params.unstake_input {
+    if input != &next_params.burnt_input || &params.public_key != &next_params.burnt_public_key {
         msg!("[ConsensusProposalBurnV1] Error: Next call input mismatch");
         return Err(MoneyError::NextCallInputMissmatch.into())
     }

src/contract/consensus/src/entrypoint/proposal_mint_v1.rs

@@ -152,7 +152,7 @@ pub(crate) fn consensus_proposal_mint_process_instruction_v1(
 
     // Verify previous call input is the same as this calls StakeInput
     let previous_params: ConsensusProposalRewardParamsV1 = deserialize(&previous.data[1..])?;
-    let previous_input = &previous_params.stake_input;
+    let previous_input = &previous_params.mint_input;
     if &previous_input != &input ||
         &previous_params.output != output ||
         &previous_params.new_serial_commit != &params.serial_commit
@@ -162,7 +162,7 @@ pub(crate) fn consensus_proposal_mint_process_instruction_v1(
     }
 
     // If spend hook is set, check its correctness
-    let previous_input = &previous_params.unstake_input;
+    let previous_input = &previous_params.burnt_input;
     if previous_input.spend_hook != ZERO &&
         previous_input.spend_hook != CONSENSUS_CONTRACT_ID.inner()
     {

src/contract/consensus/src/entrypoint/proposal_reward_v1.rs

@@ -16,10 +16,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-use darkfi_money_contract::{
-    error::MoneyError, model::ConsensusUnstakeParamsV1,
-    CONSENSUS_CONTRACT_ZKAS_PROPOSAL_REWARD_NS_V1,
-};
+use darkfi_money_contract::{error::MoneyError, CONSENSUS_CONTRACT_ZKAS_PROPOSAL_REWARD_NS_V1};
 use darkfi_sdk::{
     crypto::{
         pasta_prelude::*, pedersen_commitment_base, pedersen_commitment_u64, poseidon_hash,
@@ -36,9 +33,9 @@ use darkfi_serial::{deserialize, Encodable, WriteExt};
 use crate::{
     error::ConsensusError,
     model::{
-        ConsensusProposalMintParamsV1, ConsensusProposalRewardParamsV1,
-        ConsensusProposalRewardUpdateV1, SlotCheckpoint, HEADSTART, MU_RHO_PREFIX, MU_Y_PREFIX,
-        REWARD, ZERO,
+        ConsensusProposalBurnParamsV1, ConsensusProposalMintParamsV1,
+        ConsensusProposalRewardParamsV1, ConsensusProposalRewardUpdateV1, SlotCheckpoint,
+        HEADSTART, MU_RHO_PREFIX, MU_Y_PREFIX, REWARD, ZERO,
     },
     ConsensusFunction,
 };
@@ -58,16 +55,19 @@ pub(crate) fn consensus_proposal_reward_get_metadata_v1(
     let mut signature_pubkeys: Vec<PublicKey> = vec![];
 
     // Grab the nullifier for the burnt coin
-    let nullifier = &params.unstake_input.nullifier;
+    let nullifier = &params.burnt_input.nullifier;
+
+    // Grab the public key coordinates for the burnt coin
+    let (pub_x, pub_y) = &params.burnt_public_key.xy();
 
     // Grab the pedersen commitment for the burnt value
-    let value_coords = &params.unstake_input.value_commit.to_affine().coordinates().unwrap();
+    let value_coords = &params.burnt_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 pedersen commitment for the minted value
-    let new_value_coords = &params.stake_input.value_commit.to_affine().coordinates().unwrap();
+    let new_value_coords = &params.mint_input.value_commit.to_affine().coordinates().unwrap();
 
     // Grab proposal coin y and rho for lottery
     let y = &params.y;
@@ -93,6 +93,8 @@ pub(crate) fn consensus_proposal_reward_get_metadata_v1(
         CONSENSUS_CONTRACT_ZKAS_PROPOSAL_REWARD_NS_V1.to_string(),
         vec![
             nullifier.inner(),
+            *pub_x,
+            *pub_y,
             *value_coords.x(),
             *value_coords.y(),
             *new_serial_coords.x(),
@@ -109,7 +111,7 @@ pub(crate) fn consensus_proposal_reward_get_metadata_v1(
         ],
     ));
 
-    signature_pubkeys.push(params.stake_input.signature_public);
+    signature_pubkeys.push(params.mint_input.signature_public);
 
     // Serialize everything gathered and return it
     let mut metadata = vec![];
@@ -133,23 +135,22 @@ pub(crate) fn consensus_proposal_reward_process_instruction_v1(
     // ===================================
 
     msg!("[ConsensusProposalRewardV1] Validating anonymous inputs");
-    let unstake_input = &params.unstake_input;
-    let stake_input = &params.stake_input;
+    let burnt_input = &params.burnt_input;
+    let mint_input = &params.mint_input;
     let output = &params.output;
 
     // Only native token can be rewarded in a proposal
-    let dark_token_commit =
-        pedersen_commitment_base(DARK_TOKEN_ID.inner(), stake_input.token_blind);
-    if unstake_input.token_commit != dark_token_commit || output.token_commit != dark_token_commit {
+    let dark_token_commit = pedersen_commitment_base(DARK_TOKEN_ID.inner(), mint_input.token_blind);
+    if burnt_input.token_commit != dark_token_commit || output.token_commit != dark_token_commit {
         msg!("[ConsensusProposalRewardV1] Error: Input used non-native token");
         return Err(MoneyError::StakeInputNonNativeToken.into())
     }
 
     // Verify value commits match
     let mut valcom_total = pallas::Point::identity();
-    valcom_total += unstake_input.value_commit;
+    valcom_total += burnt_input.value_commit;
     valcom_total += pedersen_commitment_u64(REWARD, pallas::Scalar::zero());
-    valcom_total -= stake_input.value_commit;
+    valcom_total -= mint_input.value_commit;
     if valcom_total != pallas::Point::identity() {
         msg!("[ConsensusProposalRewardV1] Error: Value commitments do not result in identity");
         return Err(MoneyError::ValueMismatch.into())
@@ -175,9 +176,9 @@ pub(crate) fn consensus_proposal_reward_process_instruction_v1(
     }
 
     // Verify previous call input is the same as this calls StakeInput
-    let previous_params: ConsensusUnstakeParamsV1 = deserialize(&previous.data[1..])?;
+    let previous_params: ConsensusProposalBurnParamsV1 = deserialize(&previous.data[1..])?;
     let previous_input = &previous_params.input;
-    if &previous_input != &unstake_input {
+    if &previous_input != &burnt_input || &previous_params.public_key != &params.burnt_public_key {
         msg!("[ConsensusProposalRewardV1] Error: Previous call input mismatch");
         return Err(MoneyError::PreviousCallInputMissmatch.into())
     }
@@ -211,7 +212,7 @@ pub(crate) fn consensus_proposal_reward_process_instruction_v1(
 
     // Verify next call StakeInput is the same as this calls input
     let next_params: ConsensusProposalMintParamsV1 = deserialize(&next.data[1..])?;
-    if stake_input != &next_params.input ||
+    if mint_input != &next_params.input ||
         output != &next_params.output ||
         &params.new_serial_commit != &next_params.serial_commit
     {

src/contract/consensus/src/model.rs

@@ -17,16 +17,29 @@
  */
 
 use darkfi_money_contract::model::{Input, Output, StakeInput};
-use darkfi_sdk::pasta::pallas;
+use darkfi_sdk::{crypto::PublicKey, pasta::pallas};
 use darkfi_serial::{SerialDecodable, SerialEncodable};
 
+/// Parameters for `Consensus::ProposalBurn`
+#[derive(Clone, Debug, SerialEncodable, SerialDecodable)]
+pub struct ConsensusProposalBurnParamsV1 {
+    /// Blinding factor for `token_id`
+    pub token_blind: pallas::Scalar,
+    /// Anonymous input
+    pub input: Input,
+    /// Burnt coin public key used in VRF
+    pub public_key: PublicKey,
+}
+
 /// Parameters for `Consensus::ProposalReward`
 #[derive(Clone, Debug, SerialEncodable, SerialDecodable)]
 pub struct ConsensusProposalRewardParamsV1 {
-    /// Anonymous input of `Consensus::Unstake`
-    pub unstake_input: Input,
-    /// Burnt token revealed info of `Consensus::Stake`
-    pub stake_input: StakeInput,
+    /// Anonymous input of `Consensus::ProposalBurn`
+    pub burnt_input: Input,
+    /// Burnt coin public key used in VRF
+    pub burnt_public_key: PublicKey,
+    /// Burnt token revealed info of `Consensus::ProposalMint`
+    pub mint_input: StakeInput,
     /// Anonymous output
     pub output: Output,
     /// Pedersen commitment for the output's serial number

src/contract/consensus/tests/stake_unstake.rs

@@ -247,8 +247,7 @@ async fn consensus_contract_stake_unstake() -> Result<()> {
 
     // With alice's current coin value she can become the slot proposer,
     // so she creates a proposal transaction to burn her staked coin,
-    // reward herself and mint the new coin. Burn and Mint use the same
-    // parameters as Unstake and Stake.
+    // reward herself and mint the new coin.
     info!(target: "consensus", "[Alice] ====================================");
     info!(target: "consensus", "[Alice] Building proposal transaction params");
     info!(target: "consensus", "[Alice] ====================================");
@@ -267,20 +266,20 @@ async fn consensus_contract_stake_unstake() -> Result<()> {
     }
     .build()?;
     let (
-        alice_consensus_unstake_params,
-        alice_consensus_unstake_proofs,
+        alice_consensus_burn_params,
+        alice_consensus_burn_proofs,
         alice_consensus_reward_params,
         alice_consensus_reward_proofs,
-        alice_consensus_stake_params,
-        alice_consensus_stake_proofs,
+        alice_consensus_mint_params,
+        alice_consensus_mint_proofs,
         alice_consensus_proposal_secret_key,
     ) = (
-        alice_consensus_proposal_call_debris.unstake_params,
-        alice_consensus_proposal_call_debris.unstake_proofs,
+        alice_consensus_proposal_call_debris.burn_params,
+        alice_consensus_proposal_call_debris.burn_proofs,
         alice_consensus_proposal_call_debris.reward_params,
         alice_consensus_proposal_call_debris.reward_proofs,
-        alice_consensus_proposal_call_debris.stake_params,
-        alice_consensus_proposal_call_debris.stake_proofs,
+        alice_consensus_proposal_call_debris.mint_params,
+        alice_consensus_proposal_call_debris.mint_proofs,
         alice_consensus_proposal_call_debris.signature_secret,
     );
 
@@ -288,32 +287,32 @@ async fn consensus_contract_stake_unstake() -> Result<()> {
     info!(target: "consensus", "[Alice] Building proposal tx");
     info!(target: "consensus", "[Alice] ====================");
     let mut data = vec![ConsensusFunction::ProposalBurnV1 as u8];
-    alice_consensus_unstake_params.encode(&mut data)?;
-    let consensus_unstake_call = ContractCall { contract_id: *CONSENSUS_CONTRACT_ID, data };
+    alice_consensus_burn_params.encode(&mut data)?;
+    let consensus_burn_call = ContractCall { contract_id: *CONSENSUS_CONTRACT_ID, data };
 
     let mut data = vec![ConsensusFunction::ProposalRewardV1 as u8];
     alice_consensus_reward_params.encode(&mut data)?;
     let consensus_reward_call = ContractCall { contract_id: *CONSENSUS_CONTRACT_ID, data };
 
     let mut data = vec![ConsensusFunction::ProposalMintV1 as u8];
-    alice_consensus_stake_params.encode(&mut data)?;
-    let consensus_stake_call = ContractCall { contract_id: *CONSENSUS_CONTRACT_ID, data };
+    alice_consensus_mint_params.encode(&mut data)?;
+    let consensus_mint_call = ContractCall { contract_id: *CONSENSUS_CONTRACT_ID, data };
 
-    let calls = vec![consensus_unstake_call, consensus_reward_call, consensus_stake_call];
+    let calls = vec![consensus_burn_call, consensus_reward_call, consensus_mint_call];
     let proofs = vec![
-        alice_consensus_unstake_proofs,
+        alice_consensus_burn_proofs,
         alice_consensus_reward_proofs,
-        alice_consensus_stake_proofs,
+        alice_consensus_mint_proofs,
     ];
     let mut alice_proposal_tx = Transaction { calls, proofs, signatures: vec![] };
-    let consensus_unstake_sigs =
+    let consensus_burn_sigs =
         alice_proposal_tx.create_sigs(&mut OsRng, &[alice_consensus_proposal_secret_key])?;
     let consensus_reward_sigs =
         alice_proposal_tx.create_sigs(&mut OsRng, &[alice_consensus_proposal_secret_key])?;
-    let consensus_stake_sigs =
+    let consensus_mint_sigs =
         alice_proposal_tx.create_sigs(&mut OsRng, &[alice_consensus_proposal_secret_key])?;
     alice_proposal_tx.signatures =
-        vec![consensus_unstake_sigs, consensus_reward_sigs, consensus_stake_sigs];
+        vec![consensus_burn_sigs, consensus_reward_sigs, consensus_mint_sigs];
     proposal_creation_times.push(timer.elapsed());
 
     // Calculate transaction sizes
@@ -338,7 +337,7 @@ async fn consensus_contract_stake_unstake() -> Result<()> {
     assert!(erroneous_txs.is_empty());
     th.faucet
         .consensus_merkle_tree
-        .append(&MerkleNode::from(alice_consensus_stake_params.output.coin.inner()));
+        .append(&MerkleNode::from(alice_consensus_mint_params.output.coin.inner()));
     proposal_verify_times.push(timer.elapsed());
 
     info!(target: "consensus", "[Alice] ===========================");
@@ -350,7 +349,7 @@ async fn consensus_contract_stake_unstake() -> Result<()> {
     assert!(erroneous_txs.is_empty());
     th.alice
         .consensus_merkle_tree
-        .append(&MerkleNode::from(alice_consensus_stake_params.output.coin.inner()));
+        .append(&MerkleNode::from(alice_consensus_mint_params.output.coin.inner()));
     proposal_verify_times.push(timer.elapsed());
 
     assert!(
@@ -361,9 +360,9 @@ async fn consensus_contract_stake_unstake() -> Result<()> {
     // Gather new staked owncoin which includes the reward
     let leaf_position = th.alice.consensus_merkle_tree.witness().unwrap();
     let note: MoneyNote =
-        alice_consensus_stake_params.output.note.decrypt(&th.alice.keypair.secret)?;
+        alice_consensus_mint_params.output.note.decrypt(&th.alice.keypair.secret)?;
     let alice_rewarded_staked_oc = OwnCoin {
-        coin: Coin::from(alice_consensus_stake_params.output.coin),
+        coin: Coin::from(alice_consensus_mint_params.output.coin),
         note: note.clone(),
         secret: th.alice.keypair.secret,
         nullifier: Nullifier::from(poseidon_hash([th.alice.keypair.secret.inner(), note.serial])),