Implement the ChangeParams transaction

Author: Seulgi Kim

core/src/consensus/stake/actions.rs

@@ -34,7 +34,7 @@ pub enum Action {
     },
     ChangeParams {
         metadata_seq: u64,
-        params: CommonParams,
+        params: Box<CommonParams>,
         signatures: Vec<Signature>,
     },
 }
@@ -62,7 +62,7 @@ impl Encodable for Action {
                 s.begin_list(3 + signatures.len())
                     .append(&ACTION_TAG_CHANGE_PARAMS)
                     .append(metadata_seq)
-                    .append(params);
+                    .append(&**params);
                 for signature in signatures {
                     s.append(signature);
                 }
@@ -110,7 +110,7 @@ impl Decodable for Action {
                     })
                 }
                 let metadata_seq = rlp.val_at(1)?;
-                let params = rlp.val_at(2)?;
+                let params = Box::new(rlp.val_at(2)?);
                 let signatures = (3..item_count).map(|i| rlp.val_at(i)).collect::<Result<_, _>>()?;
                 Ok(Action::ChangeParams {
                     metadata_seq,
@@ -133,7 +133,7 @@ mod tests {
     fn decode_fail_if_change_params_have_no_signatures() {
         let action = Action::ChangeParams {
             metadata_seq: 3,
-            params: CommonParams::default_for_test(),
+            params: CommonParams::default_for_test().into(),
             signatures: vec![],
         };
         assert_eq!(
@@ -149,7 +149,7 @@ mod tests {
     fn rlp_of_change_params() {
         rlp_encode_and_decode_test!(Action::ChangeParams {
             metadata_seq: 3,
-            params: CommonParams::default_for_test(),
+            params: CommonParams::default_for_test().into(),
             signatures: vec![Signature::random(), Signature::random()],
         });
     }

core/src/consensus/stake/mod.rs

@@ -23,9 +23,10 @@ use std::ops::Deref;
 use std::sync::Arc;
 
 use ccrypto::Blake;
-use ckey::{recover, Address};
-use cstate::{ActionHandler, StateResult, TopLevelState};
+use ckey::{public_to_address, recover, Address, Signature};
+use cstate::{ActionHandler, StateResult, TopLevelState, TopState};
 use ctypes::errors::{RuntimeError, SyntaxError};
+use ctypes::util::unexpected::Mismatch;
 use ctypes::{CommonParams, Header};
 use primitives::H256;
 use rlp::{Decodable, UntrustedRlp};
@@ -114,8 +115,10 @@ impl ActionHandler for Stake {
                 }
             }
             Action::ChangeParams {
-                ..
-            } => unimplemented!(),
+                metadata_seq,
+                params,
+                signatures,
+            } => change_params(state, metadata_seq, *params, &signatures),
         }
     }
 
@@ -215,6 +218,40 @@ pub fn get_stakes(state: &TopLevelState) -> StateResult<HashMap<Address, u64>> {
     Ok(result)
 }
 
+fn change_params(
+    state: &mut TopLevelState,
+    metadata_seq: u64,
+    params: CommonParams,
+    signatures: &[Signature],
+) -> StateResult<()> {
+    // Update state first because the signature validation is more expensive.
+    state.update_params(metadata_seq, params)?;
+
+    let action = Action::ChangeParams {
+        metadata_seq,
+        params: params.into(),
+        signatures: vec![],
+    };
+    let encoded_action = H256::blake(rlp::encode(&action));
+    let stakes = get_stakes(state)?;
+    let signed_stakes = signatures.iter().try_fold(0, |sum, signature| {
+        let public = recover(signature, &encoded_action).unwrap_or_else(|err| {
+            unreachable!("The transaction with an invalid signature cannot pass the verification: {}", err);
+        });
+        let address = public_to_address(&public);
+        stakes.get(&address).map(|stake| sum + stake).ok_or_else(|| RuntimeError::SignatureOfInvalidAccount(address))
+    })?;
+    let total_stakes: u64 = stakes.values().sum();
+    if total_stakes / 2 >= signed_stakes {
+        return Err(RuntimeError::InsufficientStakes(Mismatch {
+            expected: total_stakes,
+            found: signed_stakes,
+        })
+        .into())
+    }
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use super::action_data::get_account_key;

spec/Staking.md

@@ -359,6 +359,7 @@ It also does not provide a voting feature.
 The vote initiator should collect the signatures through the off-chain.
 
 This transaction increases the `seq` of `Metadata` and changes the `params` of `Metadata`.
+The changed parameters are applied from the next block that the changing transaction is included.
 
 ### Action
 `[ 0xFF, metadata_seq, new_parameters, ...signatures ]`

state/src/impls/top_level.rs

@@ -46,7 +46,7 @@ use ctypes::transaction::{
     Action, AssetOutPoint, AssetTransferInput, AssetWrapCCCOutput, ShardTransaction, Transaction,
 };
 use ctypes::util::unexpected::Mismatch;
-use ctypes::{BlockNumber, ShardId};
+use ctypes::{BlockNumber, CommonParams, ShardId};
 use cvm::ChainTimeInfo;
 use hashdb::AsHashDB;
 use kvdb::DBTransaction;
@@ -989,6 +989,21 @@ impl TopState for TopLevelState {
     fn remove_action_data(&mut self, key: &H256) {
         self.top_cache.remove_action_data(key)
     }
+
+    fn update_params(&mut self, metadata_seq: u64, params: CommonParams) -> StateResult<()> {
+        let mut metadata = self.get_metadata_mut()?;
+        if metadata.seq() != metadata_seq {
+            return Err(RuntimeError::InvalidSeq(Mismatch {
+                found: metadata_seq,
+                expected: metadata.seq(),
+            })
+            .into())
+        }
+
+        metadata.set_params(params);
+        metadata.increase_seq();
+        Ok(())
+    }
 }
 
 fn is_active_account(state: &TopStateView, address: &Address) -> TrieResult<bool> {

state/src/item/metadata.rs

@@ -14,11 +14,10 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
+use ctypes::{CommonParams, ShardId};
 use primitives::H256;
 use rlp::{Decodable, DecoderError, Encodable, RlpStream, UntrustedRlp};
 
-use ctypes::{CommonParams, ShardId};
-
 use crate::CacheableItem;
 
 #[derive(Clone, Debug, Default, PartialEq)]
@@ -33,7 +32,7 @@ pub struct Metadata {
     number_of_initial_shards: ShardId,
     hashes: Vec<H256>,
     term: TermMetadata,
-    seq: usize,
+    seq: u64,
     params: Option<CommonParams>,
 }
 
@@ -78,10 +77,22 @@ impl Metadata {
         })
     }
 
+    pub fn seq(&self) -> u64 {
+        self.seq
+    }
+
+    pub fn increase_seq(&mut self) {
+        self.seq += 1;
+    }
+
     pub fn params(&self) -> Option<&CommonParams> {
         self.params.as_ref()
     }
 
+    pub fn set_params(&mut self, params: CommonParams) {
+        self.params = Some(params);
+    }
+
     pub fn change_term(&mut self, last_term_finished_block_num: u64, current_term_id: u64) {
         assert!(self.term.last_term_finished_block_num < last_term_finished_block_num);
         assert!(self.term.current_term_id < current_term_id);

state/src/traits.rs

@@ -17,7 +17,7 @@
 use ckey::{public_to_address, Address, Public, Signature};
 use cmerkle::Result as TrieResult;
 use ctypes::transaction::ShardTransaction;
-use ctypes::{BlockNumber, ShardId};
+use ctypes::{BlockNumber, CommonParams, ShardId};
 use cvm::ChainTimeInfo;
 use primitives::{Bytes, H160, H256};
 
@@ -181,6 +181,8 @@ pub trait TopState {
 
     fn update_action_data(&mut self, key: &H256, data: Bytes) -> StateResult<()>;
     fn remove_action_data(&mut self, key: &H256);
+
+    fn update_params(&mut self, metadata_seq: u64, params: CommonParams) -> StateResult<()>;
 }
 
 pub trait StateWithCache {