Implement report_double_vote custom action

Author: HoOngEe

core/src/consensus/mod.rs

@@ -34,6 +34,7 @@ pub use self::solo::Solo;
 pub use self::tendermint::{Tendermint, TendermintParams, TimeGapParams};
 pub use self::validator_set::validator_list::RoundRobinValidator;
 pub use self::validator_set::ValidatorSet;
+pub use self::vote_collector::Message;
 
 use std::fmt;
 use std::sync::{Arc, Weak};
@@ -273,6 +274,10 @@ pub trait ConsensusEngine: Sync + Send {
         self.action_handlers().iter().find(|handler| handler.handler_id() == id).map(AsRef::as_ref)
     }
 
+    fn get_validator_set(&self) -> Option<Arc<ValidatorSet>> {
+        None
+    }
+
     fn possible_authors(&self, block_number: Option<u64>) -> Result<Option<Vec<Address>>, EngineError>;
 }
 
@@ -353,6 +358,7 @@ pub trait CodeChainEngine: ConsensusEngine {
         &self,
         tx: &UnverifiedTransaction,
         common_params: &CommonParams,
+        parent: &H256,
     ) -> Result<(), Error> {
         if let Action::Custom {
             handler_id,

core/src/consensus/solo/mod.rs

@@ -18,16 +18,18 @@ mod params;
 
 use std::sync::Arc;
 
-use ckey::Address;
+use ckey::{Address, SchnorrSignature};
 use cstate::{ActionHandler, HitHandler};
 use ctypes::{CommonParams, Header};
+use primitives::{Bytes, H256};
+use rlp::{Decodable, DecoderError, Encodable, RlpStream, UntrustedRlp};
 
 use self::params::SoloParams;
 use super::stake;
 use super::{ConsensusEngine, Seal};
 use crate::block::{ExecutedBlock, IsBlock};
 use crate::codechain_machine::CodeChainMachine;
-use crate::consensus::{EngineError, EngineType};
+use crate::consensus::{EngineError, EngineType, Message};
 use crate::error::Error;
 
 /// A consensus engine which does not provide any consensus mechanism.
@@ -37,14 +39,57 @@ pub struct Solo {
     action_handlers: Vec<Arc<ActionHandler>>,
 }
 
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Default)]
+pub struct SoloMessage {}
+
+impl Encodable for SoloMessage {
+    fn rlp_append(&self, s: &mut RlpStream) {
+        s.append_empty_data();
+    }
+}
+
+impl Decodable for SoloMessage {
+    fn decode(_rlp: &UntrustedRlp) -> Result<Self, DecoderError> {
+        Ok(SoloMessage {})
+    }
+}
+
+impl Message for SoloMessage {
+    type Round = bool;
+
+    fn signature(&self) -> SchnorrSignature {
+        SchnorrSignature::random()
+    }
+
+    fn signer_index(&self) -> usize {
+        Default::default()
+    }
+
+    fn block_hash(&self) -> Option<H256> {
+        None
+    }
+
+    fn round(&self) -> &bool {
+        &false
+    }
+
+    fn is_broadcastable(&self) -> bool {
+        false
+    }
+
+    fn message_for_signature(&self) -> Bytes {
+        Default::default()
+    }
+}
+
 impl Solo {
     /// Returns new instance of Solo over the given state machine.
     pub fn new(params: SoloParams, machine: CodeChainMachine) -> Self {
         let mut action_handlers: Vec<Arc<ActionHandler>> = Vec::new();
         if params.enable_hit_handler {
             action_handlers.push(Arc::new(HitHandler::new()));
         }
-        action_handlers.push(Arc::new(stake::Stake::new(params.genesis_stakes.clone())));
+        action_handlers.push(Arc::new(stake::Stake::<SoloMessage>::new(params.genesis_stakes.clone())));
 
         Solo {
             params,

core/src/consensus/stake/actions.rs

@@ -14,21 +14,28 @@
 // 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 ccrypto::Blake;
-use ckey::{recover, Address, Signature};
+use std::sync::{Arc, Weak};
+
+use ccrypto::{blake256, Blake};
+use ckey::{recover, verify_schnorr, Address, Public, Signature};
+use client::ConsensusClient;
+use consensus::vote_collector::Message;
 use ctypes::errors::SyntaxError;
 use ctypes::CommonParams;
 use primitives::{Bytes, H256};
 use rlp::{Decodable, DecoderError, Encodable, RlpStream, UntrustedRlp};
 
+use consensus::stake::get_validators;
+
 const ACTION_TAG_TRANSFER_CCS: u8 = 1;
 const ACTION_TAG_DELEGATE_CCS: u8 = 2;
 const ACTION_TAG_REVOKE: u8 = 3;
 const ACTION_TAG_SELF_NOMINATE: u8 = 4;
+const ACTION_TAG_REPORT_DOUBLE_VOTE: u8 = 5;
 const ACTION_TAG_CHANGE_PARAMS: u8 = 0xFF;
 
 #[derive(Debug, PartialEq)]
-pub enum Action {
+pub enum Action<M: Message> {
     TransferCCS {
         address: Address,
         quantity: u64,
@@ -50,10 +57,18 @@ pub enum Action {
         params: Box<CommonParams>,
         signatures: Vec<Signature>,
     },
+    ReportDoubleVote {
+        message1: M,
+        message2: M,
+    },
 }
 
-impl Action {
-    pub fn verify(&self, current_params: &CommonParams) -> Result<(), SyntaxError> {
+impl<M: Message> Action<M> {
+    pub fn verify(
+        &self,
+        current_params: &CommonParams,
+        client: Option<Weak<ConsensusClient>>,
+    ) -> Result<(), SyntaxError> {
         match self {
             Action::TransferCCS {
                 ..
@@ -89,7 +104,7 @@ impl Action {
                     )))
                 }
                 params.verify().map_err(SyntaxError::InvalidCustomAction)?;
-                let action = Action::ChangeParams {
+                let action = Action::<M>::ChangeParams {
                     metadata_seq: *metadata_seq,
                     params: params.clone(),
                     signatures: vec![],
@@ -102,12 +117,60 @@ impl Action {
                     })?;
                 }
             }
+            Action::ReportDoubleVote {
+                message1,
+                message2,
+            } => {
+                // what is the general verifying for general message?
+                let message_for_signature = message1.message_for_signature();
+                let message_hash = blake256(&message_for_signature);
+
+                let signature1 = message1.signature();
+                let signature2 = message2.signature();
+
+                let signer_idx1 = message1.signer_index();
+                let signer_idx2 = message2.signer_index();
+
+                let signed_block_hash = message1.block_hash();
+                let client: Arc<ConsensusClient> =
+                    client.as_ref().and_then(Weak::upgrade).expect("Client must be initialized");
+                let parent_block_hash = signed_block_hash
+                    .and_then(|hash| client.block_header(&hash.into()))
+                    .ok_or_else(|| {
+                        SyntaxError::InvalidCustomAction(String::from(
+                            "Cannot get parent header from message's block_hash",
+                        ))
+                    })?
+                    .parent_hash();
+
+                let parent_state = client.state_at(parent_block_hash.into()).ok_or_else(|| {
+                    SyntaxError::InvalidCustomAction(String::from(
+                        "Cannot read state from the given message's parent hash",
+                    ))
+                })?;
+                let signers_vec: Vec<Public> = get_validators(&parent_state)
+                    .map(|validators| validators.into_iter().map(|val| *val.pubkey()).collect())
+                    .map_err(|_| {
+                        SyntaxError::InvalidCustomAction(String::from("Cannot get validators from parent_state"))
+                    })?;
+
+                let signer1 = signers_vec.get(signer_idx1).ok_or_else(|| {
+                    SyntaxError::InvalidCustomAction(String::from("Invalid signer index in message1"))
+                })?;
+                let signer2 = signers_vec.get(signer_idx2).ok_or_else(|| {
+                    SyntaxError::InvalidCustomAction(String::from("Invalid signer index in message2"))
+                })?;
+
+                verify_schnorr(signer1, &signature1, &message_hash)
+                    .and(verify_schnorr(signer2, &signature2, &message_hash))
+                    .map_err(|err| SyntaxError::InvalidCustomAction(format!("{}", err)))?;
+            }
         }
         Ok(())
     }
 }
 
-impl Encodable for Action {
+impl<M: Message> Encodable for Action<M> {
     fn rlp_append(&self, s: &mut RlpStream) {
         match self {
             Action::TransferCCS {
@@ -147,11 +210,17 @@ impl Encodable for Action {
                     s.append(signature);
                 }
             }
+            Action::ReportDoubleVote {
+                message1,
+                message2,
+            } => {
+                s.begin_list(3).append(&ACTION_TAG_REPORT_DOUBLE_VOTE).append(message1).append(message2);
+            }
         };
     }
 }
 
-impl Decodable for Action {
+impl<M: Message> Decodable for Action<M> {
     fn decode(rlp: &UntrustedRlp) -> Result<Self, DecoderError> {
         let tag = rlp.val_at(0)?;
         match tag {
@@ -224,6 +293,21 @@ impl Decodable for Action {
                     signatures,
                 })
             }
+            ACTION_TAG_REPORT_DOUBLE_VOTE => {
+                let item_count = rlp.item_count()?;
+                if item_count != 3 {
+                    return Err(DecoderError::RlpIncorrectListLen {
+                        expected: 3,
+                        got: item_count,
+                    })
+                }
+                let message1 = rlp.val_at(1)?;
+                let message2 = rlp.val_at(2)?;
+                Ok(Action::ReportDoubleVote {
+                    message1,
+                    message2,
+                })
+            }
             _ => Err(DecoderError::Custom("Unexpected Tendermint Stake Action Type")),
         }
     }
@@ -247,7 +331,7 @@ mod tests {
                 expected: 4,
                 got: 3,
             }),
-            UntrustedRlp::new(&rlp::encode(&action)).as_val::<Action>()
+            UntrustedRlp::new(&rlp::encode(&action)).as_val::<Action>::<_>()
         );
     }