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};
@@ -279,6 +280,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>;
 }
 
@@ -359,6 +364,7 @@ pub trait CodeChainEngine: ConsensusEngine {
         &self,
         tx: &UnverifiedTransaction,
         common_params: &CommonParams,
+        parent: &H256,
     ) -> Result<(), Error> {
         if let Action::Custom {
             handler_id,
@@ -368,7 +374,8 @@ pub trait CodeChainEngine: ConsensusEngine {
             let handler = self
                 .find_action_handler_for(*handler_id)
                 .ok_or_else(|| SyntaxError::InvalidCustomAction(format!("{} is an invalid handler id", handler_id)))?;
-            handler.verify(bytes, common_params)?;
+            let validators = self.get_validator_set().map(|set| set.get_whole_publics(parent));
+            handler.verify(bytes, common_params, validators)?;
         }
         self.machine().verify_transaction_with_params(tx, common_params)
     }

core/src/consensus/solo/mod.rs

@@ -18,16 +18,18 @@ mod params;
 
 use std::sync::Arc;
 
-use ckey::Address;
+use ckey::{Address, SchnorrSignature};
+use primitives::{Bytes, H256};
 use cstate::{ActionHandler, HitHandler};
 use ctypes::{CommonParams, Header};
+use rlp::{Decodable, Encodable, UntrustedRlp, RlpStream, DecoderError};
 
 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,45 @@ 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,24 @@
 // 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 ccrypto::{blake256, Blake};
+use ckey::{recover, verify_schnorr, Address, Public, Signature};
 use ctypes::errors::SyntaxError;
 use ctypes::CommonParams;
 use primitives::{Bytes, H256};
 use rlp::{Decodable, DecoderError, Encodable, RlpStream, UntrustedRlp};
 
+use consensus::vote_collector::Message;
+
 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 +53,14 @@ 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, signers: Option<Vec<Public>>) -> Result<(), SyntaxError> {
         match self {
             Action::TransferCCS {
                 ..
@@ -102,12 +109,40 @@ 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 signers = signers.ok_or(SyntaxError::InvalidCustomAction(String::from(
+                    "ReportDoubleVote Custom action is invalid for consensus engines without validators",
+                )))?;
+                let signer1 = signers
+                    .get(signer_idx1)
+                    .ok_or(SyntaxError::InvalidCustomAction(String::from("Invalid signer index")))?;
+                let signer2 = signers
+                    .get(signer_idx2)
+                    .ok_or(SyntaxError::InvalidCustomAction(String::from("Invalid signer index")))?;
+
+                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 +182,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 +265,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 +303,7 @@ mod tests {
                 expected: 4,
                 got: 3,
             }),
-            UntrustedRlp::new(&rlp::encode(&action)).as_val::<Action>()
+            UntrustedRlp::new(&rlp::encode(&action)).as_val::<Action>::<_>()
         );
     }
 

core/src/consensus/stake/mod.rs

@@ -30,27 +30,31 @@ use ctypes::{CommonParams, Header};
 use primitives::{Bytes, H256};
 use rlp::{Decodable, UntrustedRlp};
 
+pub use self::action_data::Banned;
 pub use self::action_data::Validators;
 use self::action_data::{Candidates, Delegation, IntermediateRewards, Jail, ReleaseResult, StakeAccount, Stakeholders};
 use self::actions::Action;
 pub use self::distribute::fee_distribute;
-use consensus::stake::action_data::Banned;
+use consensus::vote_collector::Message;
+use std::marker::PhantomData;
 
 const CUSTOM_ACTION_HANDLER_ID: u64 = 2;
 
-pub struct Stake {
+pub struct Stake<M> {
     genesis_stakes: HashMap<Address, u64>,
+    phantom: PhantomData<M>,
 }
 
-impl Stake {
-    pub fn new(genesis_stakes: HashMap<Address, u64>) -> Stake {
+impl<M> Stake<M> {
+    pub fn new(genesis_stakes: HashMap<Address, u64>) -> Stake<M> {
         Stake {
             genesis_stakes,
+            phantom: PhantomData,
         }
     }
 }
 
-impl ActionHandler for Stake {
+impl<M: Message> ActionHandler for Stake<M> {
     fn name(&self) -> &'static str {
         "stake handler"
     }
@@ -80,7 +84,7 @@ impl ActionHandler for Stake {
         sender: &Address,
         sender_public: &Public,
     ) -> StateResult<()> {
-        let action = Action::decode(&UntrustedRlp::new(bytes)).expect("Verification passed");
+        let action = Action::<M>::decode(&UntrustedRlp::new(bytes)).expect("Verification passed");
         match action {
             Action::TransferCCS {
                 address,
@@ -116,13 +120,22 @@ impl ActionHandler for Stake {
                 params,
                 signatures,
             } => change_params(state, metadata_seq, *params, &signatures),
+            Action::ReportDoubleVote {
+                message1,
+                ..
+            } => ban_double_vote_account(state, sender_public, message1),
         }
     }
 
-    fn verify(&self, bytes: &[u8], current_params: &CommonParams) -> Result<(), SyntaxError> {
-        let action = Action::decode(&UntrustedRlp::new(bytes))
+    fn verify(
+        &self,
+        bytes: &[u8],
+        current_params: &CommonParams,
+        validators: Option<Vec<Public>>,
+    ) -> Result<(), SyntaxError> {
+        let action = Action::<M>::decode(&UntrustedRlp::new(bytes))
             .map_err(|err| SyntaxError::InvalidCustomAction(err.to_string()))?;
-        action.verify(current_params)
+        action.verify(current_params, validators)
     }
 
     fn on_close_block(
@@ -228,6 +241,19 @@ fn self_nominate(
     Ok(())
 }
 
+pub fn ban_double_vote_account<M: Message>(
+    state: &TopLevelState,
+    sender_public: &Public,
+    message: M,
+) -> StateResult<()> {
+    let idx = message.signer_index();
+    let validators = get_validators(state)?;
+    let pubkey = validators.pubkeys().get(idx).expect("Index was verified");
+
+    ban(&mut state, sender_public, public_to_address(pubkey))?;
+    Ok(())
+}
+
 pub fn get_stakes(state: &TopLevelState) -> StateResult<HashMap<Address, u64>> {
     let stakeholders = Stakeholders::load_from_state(state)?;
     let mut result = HashMap::new();
@@ -243,6 +269,10 @@ pub fn get_validators(state: &TopLevelState) -> StateResult<Validators> {
     Validators::load_from_state(state)
 }
 
+pub fn get_banned_accounts(state: &TopLevelState) -> StateResult<Banned> {
+    Banned::load_from_state(state)
+}
+
 pub fn add_intermediate_rewards(state: &mut TopLevelState, address: Address, reward: u64) -> StateResult<()> {
     let mut rewards = IntermediateRewards::load_from_state(state)?;
     rewards.add_quantity(address, reward);
@@ -284,7 +314,7 @@ fn change_params(
     // Update state first because the signature validation is more expensive.
     state.update_params(metadata_seq, params)?;
 
-    let action = Action::ChangeParams {
+    let action = Action::<Message>::ChangeParams {
         metadata_seq,
         params: params.into(),
         signatures: vec![],
@@ -381,16 +411,24 @@ pub fn jail(state: &mut TopLevelState, address: &Address, custody_until: u64, ki
     Ok(())
 }
 
-#[allow(dead_code)]
-pub fn ban(state: &mut TopLevelState, criminal: Address) -> StateResult<()> {
+pub fn ban(state: &mut TopLevelState, informant: &Public, criminal: Address) -> StateResult<()> {
     // TODO: remove pending rewards.
-    // TODO: give criminal's deposits to the informant
     // TODO: give criminal's rewards to diligent validators
     let mut candidates = Candidates::load_from_state(state)?;
     let mut banned = Banned::load_from_state(state)?;
     let mut jailed = Jail::load_from_state(state)?;
     let mut validators = Validators::load_from_state(state)?;
 
+    // confiscate criminal's deposit and give the same deposit amount to the informant.
+    let criminal_info = candidates.get_candidate(&criminal).expect("criminal is always a validator");
+    let informant_info =
+        candidates.get_candidate(&public_to_address(informant)).expect("informant is always a validator");
+    candidates.add_deposit(
+        informant,
+        criminal_info.deposit,
+        informant_info.nomination_ends_at,
+        informant_info.metadata,
+    );
     candidates.remove(&criminal);
     jailed.remove(&criminal);
     banned.add(criminal);