feat(staking): implement unstaking logic

Author: Tommytrg

data_structures/src/staking/stakes.rs

@@ -7,7 +7,12 @@ use std::{
 use itertools::Itertools;
 use serde::{Deserialize, Serialize};
 
-use crate::{chain::PublicKeyHash, get_environment, transaction::StakeTransaction, wit::Wit};
+use crate::{
+    chain::PublicKeyHash,
+    get_environment,
+    transaction::{StakeTransaction, UnstakeTransaction},
+    wit::Wit,
+};
 
 use super::prelude::*;
 
@@ -414,6 +419,49 @@ where
     Ok(())
 }
 
+/// Removes stake, based on the data from a unstake transaction.
+///
+/// This function was made static instead of adding it to `impl Stakes` because it is not generic over `Address` and
+/// `Coins`.
+pub fn process_unstake_transaction<Epoch, Power>(
+    stakes: &mut Stakes<PublicKeyHash, Wit, Epoch, Power>,
+    transaction: &UnstakeTransaction,
+) -> StakingResult<(), PublicKeyHash, Wit, Epoch>
+where
+    Epoch: Copy
+        + Default
+        + Sub<Output = Epoch>
+        + num_traits::Saturating
+        + From<u32>
+        + Debug
+        + Display
+        + Send
+        + Sync,
+    Power: Add<Output = Power> + Copy + Default + Div<Output = Power> + Ord + Debug,
+    Wit: Mul<Epoch, Output = Power>,
+    u64: From<Wit> + From<Power>,
+{
+    let key: StakeKey<PublicKeyHash> = StakeKey {
+        validator: transaction.body.operator,
+        withdrawer: transaction.body.withdrawal.pkh,
+    };
+
+    let coins = Wit::from_nanowits(transaction.body.withdrawal.value);
+
+    let environment = get_environment();
+    log::debug!(
+        "{} removed {} Wit stake",
+        key.validator.bech32(environment),
+        coins.wits_and_nanowits().0,
+    );
+
+    stakes.remove_stake(key, coins)?;
+
+    log::debug!("Current state of the stakes tracker: {:#?}", stakes);
+
+    Ok(())
+}
+
 /// Adds stakes, based on the data from multiple stake transactions.
 ///
 /// This function was made static instead of adding it to `impl Stakes` because it is not generic over `Address` and
@@ -443,6 +491,34 @@ where
 
     Ok(())
 }
+/// Removes stakes, based on the data from multiple unstake transactions.
+///
+/// This function was made static instead of adding it to `impl Stakes` because it is not generic over `Address` and
+/// `Coins`.
+pub fn process_unstake_transactions<'a, Epoch, Power>(
+    stakes: &mut Stakes<PublicKeyHash, Wit, Epoch, Power>,
+    transactions: impl Iterator<Item = &'a UnstakeTransaction>,
+) -> Result<(), StakesError<PublicKeyHash, Wit, Epoch>>
+where
+    Epoch: Copy
+        + Default
+        + Sub<Output = Epoch>
+        + num_traits::Saturating
+        + From<u32>
+        + Debug
+        + Send
+        + Sync
+        + Display,
+    Power: Add<Output = Power> + Copy + Default + Div<Output = Power> + Ord + Debug,
+    Wit: Mul<Epoch, Output = Power>,
+    u64: From<Wit> + From<Power>,
+{
+    for transaction in transactions {
+        process_unstake_transaction(stakes, transaction)?;
+    }
+
+    Ok(())
+}
 
 #[cfg(test)]
 mod tests {

data_structures/src/transaction.rs

@@ -837,7 +837,7 @@ impl UnstakeTransaction {
 #[derive(Debug, Default, Eq, PartialEq, Clone, Serialize, Deserialize, ProtobufConvert, Hash)]
 #[protobuf_convert(pb = "witnet::UnstakeTransactionBody")]
 pub struct UnstakeTransactionBody {
-    pub validator: PublicKeyHash,
+    pub operator: PublicKeyHash,
     pub withdrawal: ValueTransferOutput,
 
     #[protobuf_convert(skip)]
@@ -847,9 +847,9 @@ pub struct UnstakeTransactionBody {
 
 impl UnstakeTransactionBody {
     /// Creates a new stake transaction body.
-    pub fn new(validator: PublicKeyHash, withdrawal: ValueTransferOutput) -> Self {
+    pub fn new(operator: PublicKeyHash, withdrawal: ValueTransferOutput) -> Self {
         UnstakeTransactionBody {
-            validator,
+            operator,
             withdrawal,
             ..Default::default()
         }

data_structures/src/transaction_factory.rs

@@ -80,7 +80,6 @@ impl NodeBalance {
 pub enum TransactionOutputs {
     DataRequest((DataRequestOutput, Option<ValueTransferOutput>)),
     Stake((StakeOutput, Option<ValueTransferOutput>)),
-    Unstake(ValueTransferOutput),
     ValueTransfer(Vec<ValueTransferOutput>),
 }
 
@@ -89,7 +88,6 @@ impl From<TransactionOutputs> for Vec<ValueTransferOutput> {
         match value {
             TransactionOutputs::DataRequest((_, change)) => change.into_iter().collect(),
             TransactionOutputs::Stake((_, change)) => change.into_iter().collect(),
-            TransactionOutputs::Unstake(output) => vec![output],
             TransactionOutputs::ValueTransfer(outputs) => outputs,
         }
     }
@@ -207,11 +205,6 @@ pub trait OutputsCollection {
                 output_value = body.value();
                 current_weight = body.weight();
             }
-            TransactionOutputs::Unstake(withdrawal) => {
-                let body = UnstakeTransactionBody::new(Default::default(), withdrawal);
-                output_value = body.value();
-                current_weight = body.weight();
-            }
             TransactionOutputs::ValueTransfer(outputs) => {
                 let body = VTTransactionBody::new(inputs, outputs);
                 output_value = body.value();
@@ -225,12 +218,8 @@ pub trait OutputsCollection {
                     .checked_add(absolute_fee.as_nanowits())
                     .ok_or(TransactionError::FeeOverflow)?;
 
-                // Avoid collecting UTXOs for unstake transactions, which use no inputs
-                let inputs = if let &TransactionOutputs::Unstake(_) = &outputs {
-                    Default::default()
-                } else {
-                    self.take_enough_utxos(amount, timestamp, block_number_limit, utxo_strategy)?
-                };
+                let inputs =
+                    self.take_enough_utxos(amount, timestamp, block_number_limit, utxo_strategy)?;
 
                 Ok(TransactionInfo {
                     fee: absolute_fee,
@@ -241,14 +230,6 @@ pub trait OutputsCollection {
             }
             Fee::Relative(priority) => {
                 let absolute_fee = priority.into_absolute(current_weight);
-                if let TransactionOutputs::Unstake(withdrawal) = outputs {
-                    return Ok(TransactionInfo {
-                        fee: absolute_fee,
-                        inputs: Default::default(),
-                        output_value,
-                        outputs: vec![withdrawal],
-                    });
-                }
 
                 let max_iterations = 1 + ((max_weight - current_weight) / INPUT_SIZE);
                 for _i in 0..max_iterations {
@@ -289,7 +270,6 @@ pub trait OutputsCollection {
 
                             body.weight()
                         }
-                        _ => unreachable!(),
                     };
 
                     if new_weight == current_weight {
@@ -793,6 +773,16 @@ pub fn build_st(
     Ok(body)
 }
 
+/// Build unstake transaction.
+pub fn build_ut(
+    withdrawal: ValueTransferOutput,
+    operator: PublicKeyHash,
+) -> Result<UnstakeTransactionBody, TransactionError> {
+    let body = UnstakeTransactionBody::new(operator, withdrawal);
+
+    Ok(body)
+}
+
 #[cfg(test)]
 mod tests {
     use std::{

node/src/actors/chain_manager/handlers.rs

@@ -16,11 +16,13 @@ use witnet_config::defaults::{
 use witnet_data_structures::{
     chain::{
         tapi::ActiveWips, Block, ChainState, CheckpointBeacon, DataRequestInfo, Epoch, Hash,
-        Hashable, NodeStats, PublicKeyHash, SuperBlockVote, SupplyInfo,
+        Hashable, NodeStats, PublicKeyHash, SuperBlockVote, SupplyInfo, ValueTransferOutput,
     },
     error::{ChainInfoError, TransactionError::DataRequestNotFound},
     staking::errors::StakesError,
-    transaction::{DRTransaction, StakeTransaction, Transaction, VTTransaction},
+    transaction::{
+        DRTransaction, StakeTransaction, Transaction, UnstakeTransaction, VTTransaction,
+    },
     transaction_factory::{self, NodeBalance},
     types::LastBeacon,
     utxo_pool::{get_utxo_info, UtxoInfo},
@@ -33,8 +35,8 @@ use crate::{
         chain_manager::{handlers::BlockBatches::*, BlockCandidate},
         messages::{
             AddBlocks, AddCandidates, AddCommitReveal, AddSuperBlock, AddSuperBlockVote,
-            AddTransaction, Broadcast, BuildDrt, BuildStake, BuildVtt, EpochNotification,
-            EstimatePriority, GetBalance, GetBalanceTarget, GetBlocksEpochRange,
+            AddTransaction, Broadcast, BuildDrt, BuildStake, BuildUnstake, BuildVtt,
+            EpochNotification, EstimatePriority, GetBalance, GetBalanceTarget, GetBlocksEpochRange,
             GetDataRequestInfo, GetHighestCheckpointBeacon, GetMemoryTransaction, GetMempool,
             GetMempoolResult, GetNodeStats, GetReputation, GetReputationResult, GetSignalingInfo,
             GetState, GetSuperBlockVotes, GetSupplyInfo, GetUtxoInfo, IsConfirmedBlock,
@@ -1357,6 +1359,65 @@ impl Handler<BuildStake> for ChainManager {
     }
 }
 
+impl Handler<BuildUnstake> for ChainManager {
+    type Result = ResponseActFuture<Self, <BuildUnstake as Message>::Result>;
+
+    fn handle(&mut self, msg: BuildUnstake, _ctx: &mut Self::Context) -> Self::Result {
+        if !msg.dry_run && self.sm_state != StateMachine::Synced {
+            return Box::pin(actix::fut::err(
+                ChainManagerError::NotSynced {
+                    current_state: self.sm_state,
+                }
+                .into(),
+            ));
+        }
+
+        let withdrawal = ValueTransferOutput {
+            time_lock: 0,
+            pkh: self.own_pkh.unwrap(),
+            value: msg.value,
+        };
+        match transaction_factory::build_ut(withdrawal, msg.operator) {
+            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)))
+                        }
+                    });
+
+                Box::pin(fut)
+            }
+        }
+    }
+}
+
 impl Handler<QueryStake> for ChainManager {
     type Result = <QueryStake as Message>::Result;
 

node/src/actors/chain_manager/mod.rs

@@ -1038,7 +1038,12 @@ impl ChainManager {
                             block_epoch,
                         );
                     }
-                    //process_unstake_transactions(stakes, block.txns.unstake_txns.iter(), block_epoch);
+
+                    let unstake_txns_count = block.txns.unstake_txns.len();
+                    if unstake_txns_count > 0 {
+                        let _ =
+                            process_unstake_transactions(stakes, block.txns.unstake_txns.iter());
+                    }
                 }
 
                 // Update bn256 public keys with block information

node/src/actors/messages.rs

@@ -30,7 +30,7 @@ use witnet_data_structures::{
     staking::{aux::StakeKey, stakes::QueryStakesKey},
     transaction::{
         CommitTransaction, DRTransaction, RevealTransaction, StakeTransaction, Transaction,
-        VTTransaction,
+        UnstakeTransaction, VTTransaction,
     },
     transaction_factory::NodeBalance,
     types::LastBeacon,
@@ -243,6 +243,36 @@ impl Message for BuildStake {
     type Result = Result<StakeTransaction, failure::Error>;
 }
 
+/// Builds an `UnstakeTransaction`
+#[derive(Clone, Debug, Default, Hash, Eq, PartialEq, Serialize, Deserialize)]
+pub struct BuildUnstake {
+    /// Amount to unstake
+    #[serde(default)]
+    pub value: u64,
+    /// Node address operating the staked coins
+    pub operator: PublicKeyHash,
+    /// Construct the transaction but do not broadcast it
+    #[serde(default)]
+    pub dry_run: bool,
+}
+
+impl Message for BuildUnstake {
+    type Result = Result<UnstakeTransaction, failure::Error>;
+}
+
+/// Builds a `UnstakeTransaction` from a list of `ValueTransferOutput`s
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
+pub struct BuildUnstakeParams {
+    /// Amount to unstake
+    #[serde(default)]
+    pub value: u64,
+    /// Node address operating the staked coins
+    pub operator: MagicEither<String, PublicKeyHash>,
+    /// Construct the transaction but do not broadcast it
+    #[serde(default)]
+    pub dry_run: bool,
+}
+
 /// Builds a `StakeTransaction` from a list of `ValueTransferOutput`s
 #[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
 pub struct BuildStakeParams {
@@ -1446,8 +1476,8 @@ impl<L, R> MagicEither<L, R> {
     }
 }
 
-impl<L, R: Default> Default for MagicEither<L, R> {
+impl<L: Default, R: Default> Default for MagicEither<L, R> {
     fn default() -> Self {
-        MagicEither::Right(R::default())
+        MagicEither::Left(L::default())
     }
 }

schemas/witnet/witnet.proto

@@ -311,9 +311,8 @@ message StakeTransaction {
 }
 
 message UnstakeTransactionBody {
-    PublicKeyHash validator = 1;
+    PublicKeyHash operator = 1;
     ValueTransferOutput withdrawal = 2;
-    ValueTransferOutput change = 3;
 }
 
 message UnstakeTransaction {