feat(transaction): add nonce to unstake transaction to prevent rebroadcasting

Author: drcpu-github

data_structures/src/error.rs

@@ -307,6 +307,12 @@ pub enum TransactionError {
         unstake, stake
     )]
     UnstakingMoreThanStaked { stake: u64, unstake: u64 },
+    /// Tried to perform an unstake action with an invalid nonce.
+    #[fail(
+        display = "Cannot unstake with an invalid nonce: {} < {}",
+        used, current
+    )]
+    UnstakeInvalidNonce { used: u64, current: u64 },
     /// An stake output with zero value does not make sense
     #[fail(display = "Transaction {} has a zero value stake output", tx_hash)]
     ZeroValueStakeOutput { tx_hash: Hash },

data_structures/src/transaction.rs

@@ -864,6 +864,7 @@ pub struct UnstakeTransactionBody {
     pub operator: PublicKeyHash,
     pub withdrawal: ValueTransferOutput,
     pub fee: u64,
+    pub nonce: u64,
 
     #[protobuf_convert(skip)]
     #[serde(skip)]
@@ -872,11 +873,17 @@ pub struct UnstakeTransactionBody {
 
 impl UnstakeTransactionBody {
     /// Creates a new stake transaction body.
-    pub fn new(operator: PublicKeyHash, withdrawal: ValueTransferOutput, fee: u64) -> Self {
+    pub fn new(
+        operator: PublicKeyHash,
+        withdrawal: ValueTransferOutput,
+        fee: u64,
+        nonce: u64,
+    ) -> Self {
         UnstakeTransactionBody {
             operator,
             withdrawal,
             fee,
+            nonce,
             ..Default::default()
         }
     }

data_structures/src/transaction_factory.rs

@@ -778,8 +778,9 @@ pub fn build_ut(
     operator: PublicKeyHash,
     withdrawal: ValueTransferOutput,
     fee: u64,
+    nonce: u64,
 ) -> Result<UnstakeTransactionBody, TransactionError> {
-    let body = UnstakeTransactionBody::new(operator, withdrawal, fee);
+    let body = UnstakeTransactionBody::new(operator, withdrawal, fee, nonce);
 
     Ok(body)
 }

node/src/actors/chain_manager/handlers.rs

@@ -22,7 +22,7 @@ use witnet_data_structures::{
     },
     error::{ChainInfoError, TransactionError::DataRequestNotFound},
     proto::versioning::ProtocolVersion,
-    staking::errors::StakesError,
+    staking::{errors::StakesError, prelude::StakeKey},
     transaction::{
         DRTransaction, StakeTransaction, Transaction, UnstakeTransaction, VTTransaction,
     },
@@ -1410,47 +1410,60 @@ impl Handler<BuildUnstake> for ChainManager {
             ));
         }
 
-        let withdrawal = ValueTransferOutput {
-            time_lock: PSEUDO_CONSENSUS_CONSTANTS_POS_UNSTAKING_DELAY_SECONDS,
-            pkh: self.own_pkh.unwrap(),
-            value: msg.value,
-        };
-        match transaction_factory::build_ut(msg.operator, withdrawal, msg.fee) {
+        match self.chain_state.stakes.query_nonce(StakeKey {
+            validator: msg.operator,
+            withdrawer: self.own_pkh.unwrap(),
+        }) {
             Err(e) => {
                 log::error!("Error when building stake transaction: {}", e);
                 Box::pin(actix::fut::err(e.into()))
             }
-            Ok(ut) => {
-                let fut = signature_mngr::sign_transaction(&ut, 1)
-                    .into_actor(self)
-                    .then(move |s, act, _ctx| match s {
-                        Ok(signature) => {
-                            let ut =
-                                UnstakeTransaction::new(ut, signature.first().unwrap().clone());
+            Ok(nonce) => {
+                let withdrawal = ValueTransferOutput {
+                    time_lock: PSEUDO_CONSENSUS_CONSTANTS_POS_UNSTAKING_DELAY_SECONDS,
+                    pkh: self.own_pkh.unwrap(),
+                    value: msg.value,
+                };
+                match transaction_factory::build_ut(msg.operator, withdrawal, msg.fee, nonce) {
+                    Err(e) => {
+                        log::error!("Error when building stake transaction: {}", e);
+                        Box::pin(actix::fut::err(e.into()))
+                    }
+                    Ok(ut) => {
+                        let fut = signature_mngr::sign_transaction(&ut, 1)
+                            .into_actor(self)
+                            .then(move |s, act, _ctx| match s {
+                                Ok(signature) => {
+                                    let ut = UnstakeTransaction::new(
+                                        ut,
+                                        signature.first().unwrap().clone(),
+                                    );
 
-                            if msg.dry_run {
-                                Either::Right(actix::fut::result(Ok(ut)))
-                            } else {
-                                let transaction = Transaction::Unstake(ut.clone());
-                                Either::Left(
-                                    act.add_transaction(
-                                        AddTransaction {
-                                            transaction,
-                                            broadcast_flag: true,
-                                        },
-                                        get_timestamp(),
-                                    )
-                                    .map_ok(move |_, _, _| ut),
-                                )
-                            }
-                        }
-                        Err(e) => {
-                            log::error!("Failed to sign stake transaction: {}", e);
-                            Either::Right(actix::fut::result(Err(e)))
-                        }
-                    });
+                                    if msg.dry_run {
+                                        Either::Right(actix::fut::result(Ok(ut)))
+                                    } else {
+                                        let transaction = Transaction::Unstake(ut.clone());
+                                        Either::Left(
+                                            act.add_transaction(
+                                                AddTransaction {
+                                                    transaction,
+                                                    broadcast_flag: true,
+                                                },
+                                                get_timestamp(),
+                                            )
+                                            .map_ok(move |_, _, _| ut),
+                                        )
+                                    }
+                                }
+                                Err(e) => {
+                                    log::error!("Failed to sign stake transaction: {}", e);
+                                    Either::Right(actix::fut::result(Err(e)))
+                                }
+                            });
 
-                Box::pin(fut)
+                        Box::pin(fut)
+                    }
+                }
             }
         }
     }

node/src/actors/chain_manager/mining.rs

@@ -946,7 +946,7 @@ pub fn build_block(
     let min_st_weight =
         StakeTransactionBody::new(vec![Input::default()], Default::default(), None).weight();
     let min_ut_weight =
-        UnstakeTransactionBody::new(PublicKeyHash::default(), Default::default(), 0).weight();
+        UnstakeTransactionBody::new(PublicKeyHash::default(), Default::default(), 0, 0).weight();
 
     for vt_tx in transactions_pool.vt_iter() {
         let transaction_weight = vt_tx.weight();

schemas/witnet/witnet.proto

@@ -314,6 +314,7 @@ message UnstakeTransactionBody {
     PublicKeyHash operator = 1;
     ValueTransferOutput withdrawal = 2;
     uint64 fee = 3;
+    uint64 nonce = 4;
 }
 
 message UnstakeTransaction {

validations/src/validations.rs

@@ -1407,6 +1407,20 @@ pub fn validate_unstake_transaction<'a>(
                 .into());
             }
 
+            // TODO: modify this to enable delegated staking with multiple withdrawer addresses on a single validator
+            let nonce = stake_entry
+                .first()
+                .map(|stake| stake.value.nonce)
+                .unwrap()
+                .into();
+            if ut_tx.body.nonce != nonce {
+                return Err(TransactionError::UnstakeInvalidNonce {
+                    used: ut_tx.body.nonce,
+                    current: nonce,
+                }
+                .into());
+            }
+
             staked_amount
         }
         Err(_) => {