Remove Custom transactions and make the stake transactions top level

core/src/consensus/mod.rs

@@ -43,7 +43,7 @@ use ckey::{Address, Signature};
 use cnetwork::NetworkService;
 use cstate::{DoubleVoteHandler, StateDB, StateResult};
 use ctypes::errors::SyntaxError;
-use ctypes::transaction::{Action, StakeAction};
+use ctypes::transaction::Action;
 use ctypes::util::unexpected::{Mismatch, OutOfBounds};
 use ctypes::{BlockHash, CommonParams, Header};
 use primitives::{Bytes, H256};
@@ -322,24 +322,14 @@ pub trait CodeChainEngine: ConsensusEngine {
         tx: &UnverifiedTransaction,
         common_params: &CommonParams,
     ) -> Result<(), Error> {
-        if let Action::Custom {
-            bytes,
-            ..
+        if let Action::ReportDoubleVote {
+            message1,
+            message2,
         } = &tx.transaction().action
         {
-            let action = rlp::decode(bytes).map_err(|err| SyntaxError::InvalidCustomAction(err.to_string()))?;
-
             let handler =
                 self.stake_handler().ok_or_else(|| SyntaxError::InvalidCustomAction("no valid handler".to_string()))?;
-            if let StakeAction::ReportDoubleVote {
-                message1,
-                message2,
-            } = &action
-            {
-                handler.verify(message1, message2)?;
-            }
-
-            action.verify(common_params)?;
+            handler.verify(message1, message2)?;
         }
         tx.verify_with_params(common_params)?;
         Ok(())

core/src/consensus/stake/mod.rs

@@ -164,10 +164,8 @@ mod tests {
     use ckey::Ed25519Public as Public;
     use cstate::tests::helpers;
     use cstate::{
-        execute_stake_action, init_stake, self_nominate, Candidate, Candidates, Delegation, Jail, StakeAccount,
-        TopStateView,
+        delegate_ccs, init_stake, self_nominate, Candidate, Candidates, Delegation, Jail, StakeAccount, TopStateView,
     };
-    use ctypes::transaction::StakeAction;
     use ctypes::CommonParams;
     use std::collections::HashMap;
 
@@ -230,7 +228,6 @@ mod tests {
     fn self_nominate_reverts_delegations_after_expiration() {
         let address_pubkey = Public::random();
         let address = public_to_address(&address_pubkey);
-        let delegator_pubkey = Public::random();
         let delegator = public_to_address(&address_pubkey);
 
         let mut state = metadata_for_election();
@@ -247,11 +244,8 @@ mod tests {
         // TODO: change with stake::execute()
         self_nominate(&mut state, &address, &address_pubkey, 0, 0, 30, b"".to_vec()).unwrap();
 
-        let action = StakeAction::DelegateCCS {
-            address,
-            quantity: 40,
-        };
-        execute_stake_action(action, &mut state, &delegator, &delegator_pubkey).unwrap();
+        let quantity = 40;
+        delegate_ccs(&mut state, &delegator, &address, quantity).unwrap();
 
         let result = on_term_close(&mut state, pseudo_term_to_block_num_calculator(29), &[]);
         assert_eq!(result, Ok(()));
@@ -426,22 +420,14 @@ mod tests {
         jail(&mut state, &[address], custody_until, released_at).unwrap();
 
         for current_term in 0..=released_at {
-            let action = StakeAction::DelegateCCS {
-                address,
-                quantity: 1,
-            };
-            let result = execute_stake_action(action, &mut state, &delegator, &delegator_pubkey);
-            assert_ne!(Ok(()), result);
+            let quantity = 1;
+            delegate_ccs(&mut state, &delegator, &address, quantity).unwrap_err();
 
             on_term_close(&mut state, pseudo_term_to_block_num_calculator(current_term), &[]).unwrap();
         }
 
-        let action = StakeAction::DelegateCCS {
-            address,
-            quantity: 1,
-        };
-        let result = execute_stake_action(action, &mut state, &delegator, &delegator_pubkey);
-        assert!(result.is_err());
+        let quantity = 1;
+        delegate_ccs(&mut state, &delegator, &address, quantity).unwrap_err();
     }
 
     #[test]
@@ -468,11 +454,8 @@ mod tests {
         let released_at = 20;
         self_nominate(&mut state, &address, &address_pubkey, deposit, 0, nominate_expire, b"".to_vec()).unwrap();
 
-        let action = StakeAction::DelegateCCS {
-            address,
-            quantity: 40,
-        };
-        execute_stake_action(action, &mut state, &delegator, &delegator_pubkey).unwrap();
+        let quantity = 40;
+        delegate_ccs(&mut state, &delegator, &address, quantity).unwrap();
 
         jail(&mut state, &[address], custody_until, released_at).unwrap();
 
@@ -510,11 +493,8 @@ mod tests {
         let released_at = 20;
         self_nominate(&mut state, &address, &address_pubkey, 0, 0, nominate_expire, b"".to_vec()).unwrap();
 
-        let action = StakeAction::DelegateCCS {
-            address,
-            quantity: 40,
-        };
-        execute_stake_action(action, &mut state, &delegator, &delegator_pubkey).unwrap();
+        let quantity = 40;
+        delegate_ccs(&mut state, &delegator, &address, quantity).unwrap();
 
         jail(&mut state, &[address], custody_until, released_at).unwrap();
 

core/src/consensus/tendermint/vote_collector.rs

@@ -17,7 +17,7 @@
 use super::{ConsensusMessage, VoteStep};
 use crate::consensus::BitSet;
 use ckey::Signature;
-use ctypes::transaction::StakeAction;
+use ctypes::transaction::Action;
 use ctypes::BlockHash;
 use rlp::{Encodable, RlpStream};
 use std::collections::{BTreeMap, HashMap};
@@ -44,8 +44,8 @@ pub struct DoubleVote {
 }
 
 impl DoubleVote {
-    pub fn to_action(&self) -> StakeAction {
-        StakeAction::ReportDoubleVote {
+    pub fn to_action(&self) -> Action {
+        Action::ReportDoubleVote {
             message1: self.vote_one.rlp_bytes(),
             message2: self.vote_two.rlp_bytes(),
         }

core/src/consensus/tendermint/worker.rs

@@ -41,7 +41,7 @@ use crate::BlockId;
 use ckey::{public_to_address, verify, Address, Signature};
 use cnetwork::{EventSender, NodeId};
 use crossbeam_channel as crossbeam;
-use ctypes::transaction::{Action, Transaction};
+use ctypes::transaction::Transaction;
 use ctypes::util::unexpected::Mismatch;
 use ctypes::{BlockHash, BlockNumber, Header};
 use primitives::Bytes;
@@ -1432,10 +1432,7 @@ impl Worker {
             seq,
             fee: 0,
             network_id,
-            action: Action::Custom {
-                handler_id: 0,
-                bytes: double.to_action().rlp_bytes(),
-            },
+            action: double.to_action(),
         };
         let signature = match self.signer.sign_ed25519(*tx.hash()) {
             Ok(signature) => signature,

foundry/auto_self_nominate.rs

@@ -21,8 +21,8 @@ use ckey::{Address, Ed25519Public as Public, Signature};
 use ckeystore::DecryptedAccount;
 use clap::ArgMatches;
 use cstate::{Banned, Candidates, Jail};
-use ctypes::transaction::StakeAction::SelfNominate;
-use ctypes::transaction::{Action, Transaction};
+use ctypes::transaction::Action::SelfNominate;
+use ctypes::transaction::Transaction;
 use primitives::{Bytes, H256};
 use std::convert::TryInto;
 use std::sync::Arc;
@@ -178,10 +178,7 @@ impl AutoSelfNomination {
             seq,
             fee: 0,
             network_id,
-            action: Action::Custom {
-                handler_id: 0,
-                bytes: selfnominate.rlp_bytes(),
-            },
+            action: selfnominate,
         };
 
         let signature = match signer.sign_ed25519(*tx.hash()) {

key/src/ed25519/signature.rs

@@ -17,7 +17,7 @@
 use super::{Private, Public};
 use primitives::H512;
 use rlp::{Decodable, DecoderError, Encodable, Rlp, RlpStream};
-use serde::{Serialize, Serializer};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 pub use sodiumoxide::crypto::sign::SIGNATUREBYTES;
 use sodiumoxide::crypto::sign::{sign_detached, verify_detached, Signature};
 use std::fmt;
@@ -102,6 +102,15 @@ impl Serialize for Ed25519Signature {
     }
 }
 
+impl<'de> Deserialize<'de> for Ed25519Signature {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>, {
+        let h512_signature = H512::deserialize(deserializer)?;
+        Ok(Self::from_slice(&h512_signature).expect("Bytes length was verified"))
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use rlp::rlp_encode_and_decode_test;