feat(node): process stake transactions when consolidating blocks

Author: aesedepece

data_structures/build.rs

@@ -14,6 +14,8 @@ fn create_path_to_protobuf_schema_env() {
 }
 
 fn main() {
+    println!("cargo:rerun-if-changed=../schemas/witnet/witnet.proto");
+
     create_path_to_protobuf_schema_env();
 
     exonum_build::protobuf_generate(

data_structures/src/chain/mod.rs

@@ -25,7 +25,7 @@ use witnet_crypto::{
     secp256k1::{
         self,
         ecdsa::{RecoverableSignature, RecoveryId, Signature as Secp256k1_Signature},
-        PublicKey as Secp256k1_PublicKey, SecretKey as Secp256k1_SecretKey,
+        Message, PublicKey as Secp256k1_PublicKey, SecretKey as Secp256k1_SecretKey,
     },
 };
 use witnet_protected::Protected;
@@ -1012,6 +1012,25 @@ impl Signature {
             }
         }
     }
+
+    pub fn verify(
+        &self,
+        msg: &Message,
+        public_key: &Secp256k1_PublicKey,
+    ) -> Result<(), failure::Error> {
+        match self {
+            Secp256k1(x) => {
+                let signature = Secp256k1_Signature::from_der(x.der.as_slice())
+                    .map_err(|_| Secp256k1ConversionError::FailSignatureConversion)?;
+
+                signature
+                    .verify(msg, public_key)
+                    .map_err(|inner| Secp256k1ConversionError::Secp256k1 { inner })?;
+
+                Ok(())
+            }
+        }
+    }
 }
 
 /// ECDSA (over secp256k1) signature
@@ -1498,11 +1517,12 @@ impl DataRequestOutput {
     }
 }
 
-#[derive(Debug, Default, Eq, PartialEq, Clone, Serialize, Deserialize, ProtobufConvert, Hash)]
+#[derive(Debug, Default, Eq, PartialEq, Clone, Hash, Serialize, Deserialize, ProtobufConvert)]
 #[protobuf_convert(pb = "crate::proto::schema::witnet::StakeOutput")]
 pub struct StakeOutput {
-    pub value: u64,
     pub authorization: KeyedSignature,
+    pub key: StakeKey<PublicKeyHash>,
+    pub value: u64,
 }
 
 impl StakeOutput {

data_structures/src/staking/aux.rs

@@ -1,9 +1,15 @@
 use std::{rc::Rc, str::FromStr, sync::RwLock};
 
+use failure::Error;
 use serde::{Deserialize, Serialize};
 
+use crate::{chain::PublicKeyHash, proto::ProtobufConvert};
+
 use super::prelude::*;
 
+/// Just a type alias for consistency of using the same data type to represent power.
+pub type Power = u64;
+
 /// The resulting type for all the fallible functions in this module.
 pub type StakingResult<T, Address, Coins, Epoch> = Result<T, StakesError<Address, Coins, Epoch>>;
 
@@ -37,14 +43,27 @@ where
 
 /// Couples a validator address with a withdrawer address together. This is meant to be used in `Stakes` as the index
 /// for the `by_key` index.
-#[derive(Clone, Debug, Deserialize, Eq, Ord, PartialEq, PartialOrd, Serialize)]
+#[derive(Clone, Debug, Default, Deserialize, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)]
 pub struct StakeKey<Address> {
     /// A validator address.
     pub validator: Address,
     /// A withdrawer address.
     pub withdrawer: Address,
 }
 
+impl ProtobufConvert for StakeKey<PublicKeyHash> {
+    type ProtoStruct = crate::proto::schema::witnet::StakeKey;
+
+    fn to_pb(&self) -> Self::ProtoStruct {
+        let _proto = Self::ProtoStruct::new();
+        todo!()
+    }
+
+    fn from_pb(_pb: Self::ProtoStruct) -> Result<Self, Error> {
+        todo!()
+    }
+}
+
 impl<Address, T> From<(T, T)> for StakeKey<Address>
 where
     T: Into<Address>,

data_structures/src/staking/errors.rs

@@ -34,6 +34,9 @@ pub enum StakesError<Address, Coins, Epoch> {
     },
     /// Tried to obtain a lock on a write-locked piece of data that is already locked.
     PoisonedLock,
+    /// The authentication signature contained within a stake transaction is not valid for the given validator and
+    /// withdrawer addresses.
+    InvalidAuthentication,
 }
 
 impl<T, Address, Coins, Epoch> From<PoisonError<T>> for StakesError<Address, Coins, Epoch> {

data_structures/src/staking/stake.rs

@@ -1,4 +1,4 @@
-use std::marker::PhantomData;
+use std::{marker::PhantomData, ops::*};
 
 use serde::{Deserialize, Serialize};
 
@@ -28,14 +28,13 @@ where
         + From<u64>
         + PartialOrd
         + num_traits::Zero
-        + std::ops::Add<Output = Coins>
-        + std::ops::Sub<Output = Coins>
-        + std::ops::Mul
-        + std::ops::Mul<Epoch, Output = Power>,
-    Epoch: Copy + Default + num_traits::Saturating + std::ops::Sub<Output = Epoch>,
-    Power: std::ops::Add<Output = Power>
-        + std::ops::Div<Output = Power>
-        + std::ops::Div<Coins, Output = Epoch>,
+        + Add<Output = Coins>
+        + Sub<Output = Coins>
+        + Mul
+        + Mul<Epoch, Output = Power>,
+    Epoch: Copy + Default + num_traits::Saturating + Sub<Output = Epoch> + From<u32>,
+    Power: Add<Output = Power> + Div<Output = Power>,
+    u64: From<Coins> + From<Power>,
 {
     /// Increase the amount of coins staked by a certain staker.
     ///
@@ -67,7 +66,9 @@ where
         let product_added = coins * epoch;
 
         let coins_after = coins_before + coins;
-        let epoch_after = (product_before + product_added) / coins_after;
+        let epoch_after = Epoch::from(
+            (u64::from(product_before + product_added) / u64::from(coins_after)) as u32,
+        );
 
         self.coins = coins_after;
         self.epochs.update_all(epoch_after);

data_structures/src/staking/stakes.rs

@@ -1,8 +1,13 @@
-use std::collections::{btree_map::Entry, BTreeMap};
+use std::{
+    collections::{btree_map::Entry, BTreeMap},
+    ops::{Add, Div, Mul, Sub},
+};
 
 use itertools::Itertools;
 use serde::{Deserialize, Serialize};
 
+use crate::{chain::PublicKeyHash, transaction::StakeTransaction, wit::Wit};
+
 use super::prelude::*;
 
 /// The main data structure that provides the "stakes tracker" functionality.
@@ -34,20 +39,16 @@ where
         + Default
         + Ord
         + From<u64>
+        + Into<u64>
         + num_traits::Zero
-        + std::ops::Add<Output = Coins>
-        + std::ops::Sub<Output = Coins>
-        + std::ops::Mul
-        + std::ops::Mul<Epoch, Output = Power>,
+        + Add<Output = Coins>
+        + Sub<Output = Coins>
+        + Mul
+        + Mul<Epoch, Output = Power>,
     Address: Clone + Ord + 'static,
-    Epoch: Copy + Default + num_traits::Saturating + std::ops::Sub<Output = Epoch>,
-    Power: Copy
-        + Default
-        + Ord
-        + std::ops::Add<Output = Power>
-        + std::ops::Div<Output = Power>
-        + std::ops::Div<Coins, Output = Epoch>
-        + 'static,
+    Epoch: Copy + Default + num_traits::Saturating + Sub<Output = Epoch> + From<u32>,
+    Power: Copy + Default + Ord + Add<Output = Power> + Div<Output = Power>,
+    u64: From<Coins> + From<Power>,
 {
     /// Register a certain amount of additional stake for a certain address and epoch.
     pub fn add_stake<ISK>(
@@ -224,6 +225,59 @@ where
     }
 }
 
+/// Adds stake, based on the data from a stake 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_stake_transaction<Epoch, Power>(
+    stakes: &mut Stakes<PublicKeyHash, Wit, Epoch, Power>,
+    transaction: &StakeTransaction,
+    epoch: Epoch,
+) -> StakingResult<(), PublicKeyHash, Wit, Epoch>
+where
+    Epoch: Copy + Default + Sub<Output = Epoch> + num_traits::Saturating + From<u32>,
+    Power:
+        Add<Output = Power> + Copy + Default + Div<Output = Power> + Ord,
+    Wit: Mul<Epoch, Output = Power>,
+    u64: From<Wit> + From<Power>,
+{
+    // This line would check that the authorization message is valid for the provided validator and withdrawer
+    // address. But it is commented out here because stake transactions should be validated upfront (when
+    // considering block candidates). The line is reproduced here for later reference when implementing those
+    // validations. Once those are in place, we're ok to remove this comment.
+    //transaction.body.authorization_is_valid().map_err(|_| StakesError::InvalidAuthentication)?;
+
+    let key = transaction.body.output.key.clone();
+    let coins = Wit::from_nanowits(transaction.body.output.value);
+
+    stakes.add_stake(key, coins, epoch)?;
+
+    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
+/// `Coins`.
+pub fn process_stake_transactions<'a, Epoch, Power>(
+    stakes: &mut Stakes<PublicKeyHash, Wit, Epoch, Power>,
+    transactions: impl Iterator<Item = &'a StakeTransaction>,
+    epoch: Epoch,
+) -> Result<(), StakesError<PublicKeyHash, Wit, Epoch>>
+where
+    Epoch: Copy + Default + Sub<Output = Epoch> + num_traits::Saturating + From<u32>,
+    Power:
+        Add<Output = Power> + Copy + Default + Div<Output = Power> + Ord,
+    Wit: Mul<Epoch, Output = Power>,
+    u64: From<Wit> + From<Power>,
+{
+    for transaction in transactions {
+        process_stake_transaction(stakes, transaction, epoch)?;
+    }
+
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

data_structures/src/transaction.rs

@@ -3,7 +3,11 @@ use std::sync::{Arc, RwLock};
 
 use protobuf::Message;
 use serde::{Deserialize, Serialize};
-use witnet_crypto::{hash::calculate_sha256, merkle::FullMerkleTree};
+
+use witnet_crypto::{
+    hash::calculate_sha256, merkle::FullMerkleTree, secp256k1::Message as Secp256k1Message,
+    signature::PublicKey,
+};
 
 use crate::{
     chain::{
@@ -754,6 +758,16 @@ pub struct StakeTransactionBody {
 }
 
 impl StakeTransactionBody {
+    pub fn authorization_is_valid(&self) -> Result<(), failure::Error> {
+        let msg = Secp256k1Message::from_digest(self.output.key.withdrawer.as_secp256k1_msg());
+        let public_key = PublicKey::from_slice(&self.output.authorization.public_key.bytes)?;
+
+        self.output
+            .authorization
+            .signature
+            .verify(&msg, &public_key)
+    }
+
     /// Construct a `StakeTransactionBody` from a list of inputs and one `StakeOutput`.
     pub fn new(
         inputs: Vec<Input>,
@@ -823,7 +837,7 @@ impl UnstakeTransaction {
 #[derive(Debug, Default, Eq, PartialEq, Clone, Serialize, Deserialize, ProtobufConvert, Hash)]
 #[protobuf_convert(pb = "witnet::UnstakeTransactionBody")]
 pub struct UnstakeTransactionBody {
-    pub operator: PublicKeyHash,
+    pub validator: PublicKeyHash,
     pub withdrawal: ValueTransferOutput,
 
     #[protobuf_convert(skip)]
@@ -833,9 +847,9 @@ pub struct UnstakeTransactionBody {
 
 impl UnstakeTransactionBody {
     /// Creates a new stake transaction body.
-    pub fn new(operator: PublicKeyHash, withdrawal: ValueTransferOutput) -> Self {
+    pub fn new(validator: PublicKeyHash, withdrawal: ValueTransferOutput) -> Self {
         UnstakeTransactionBody {
-            operator,
+            validator,
             withdrawal,
             ..Default::default()
         }