Add SignatureData type

Author: kseo

core/src/consensus/solo_authority/mod.rs

@@ -18,8 +18,8 @@ mod params;
 
 use std::sync::{Arc, Weak};
 
-use ckey::{public_to_address, recover, Signature};
-use ctypes::{Address, H256, H520, U256};
+use ckey::{public_to_address, recover, Signature, SignatureData};
+use ctypes::{Address, H256, U256};
 use parking_lot::RwLock;
 
 use self::params::SoloAuthorityParams;
@@ -69,7 +69,7 @@ fn verify_external(header: &Header, validators: &ValidatorSet) -> Result<(), Err
     use rlp::UntrustedRlp;
 
     // Check if the signature belongs to a validator, can depend on parent state.
-    let sig = UntrustedRlp::new(&header.seal()[0]).as_val::<H520>()?;
+    let sig = UntrustedRlp::new(&header.seal()[0]).as_val::<SignatureData>()?;
     let signer = public_to_address(&recover(&sig.into(), &header.bare_hash())?);
 
     if *header.author() != signer {
@@ -107,7 +107,7 @@ impl ConsensusEngine<CodeChainMachine> for SoloAuthority {
         if self.validators.contains(header.parent_hash(), author) {
             // account should be permanently unlocked, otherwise sealing will fail
             if let Ok(signature) = self.sign(header.bare_hash()) {
-                return Seal::Regular(vec![::rlp::encode(&(&H520::from(signature) as &[u8])).into_vec()])
+                return Seal::Regular(vec![::rlp::encode(&(&SignatureData::from(signature) as &[u8])).into_vec()])
             } else {
                 ctrace!(SOLO_AUTHORITY, "generate_seal: FAIL: accounts secret key unavailable");
             }
@@ -192,7 +192,7 @@ impl ConsensusEngine<CodeChainMachine> for SoloAuthority {
 
 #[cfg(test)]
 mod tests {
-    use ctypes::H520;
+    use ckey::SignatureData;
 
     use super::super::super::block::{IsBlock, OpenBlock};
     use super::super::super::header::Header;
@@ -210,7 +210,7 @@ mod tests {
     fn can_do_signature_verification_fail() {
         let engine = Spec::new_test_solo_authority().engine;
         let mut header: Header = Header::default();
-        header.set_seal(vec![::rlp::encode(&H520::default()).into_vec()]);
+        header.set_seal(vec![::rlp::encode(&SignatureData::default()).into_vec()]);
 
         let verify_result = engine.verify_block_external(&header);
         assert!(verify_result.is_err());

core/src/consensus/tendermint/message.rs

@@ -17,8 +17,8 @@
 use std::cmp;
 
 use ccrypto::blake256;
-use ckey::{public_to_address, recover};
-use ctypes::{Address, Bytes, H256, H520};
+use ckey::{public_to_address, recover, SignatureData};
+use ctypes::{Address, Bytes, H256};
 use rlp::{Decodable, DecoderError, Encodable, RlpStream, UntrustedRlp};
 
 use super::super::super::error::Error;
@@ -123,11 +123,17 @@ impl Decodable for TendermintMessage {
 pub struct ConsensusMessage {
     pub vote_step: VoteStep,
     pub block_hash: Option<BlockHash>,
-    pub signature: H520,
+    pub signature: SignatureData,
 }
 
 impl ConsensusMessage {
-    pub fn new(signature: H520, height: Height, view: View, step: Step, block_hash: Option<BlockHash>) -> Self {
+    pub fn new(
+        signature: SignatureData,
+        height: Height,
+        view: View,
+        step: Step,
+        block_hash: Option<BlockHash>,
+    ) -> Self {
         ConsensusMessage {
             signature,
             block_hash,
@@ -158,15 +164,15 @@ pub fn consensus_view(header: &Header) -> Result<View, ::rlp::DecoderError> {
 }
 
 /// Proposal signature.
-pub fn proposal_signature(header: &Header) -> Result<H520, ::rlp::DecoderError> {
+pub fn proposal_signature(header: &Header) -> Result<SignatureData, ::rlp::DecoderError> {
     UntrustedRlp::new(header.seal().get(1).expect("seal passed basic verification; seal has 3 fields; qed").as_slice())
         .as_val()
 }
 
 impl Message for ConsensusMessage {
     type Round = VoteStep;
 
-    fn signature(&self) -> H520 {
+    fn signature(&self) -> SignatureData {
         self.signature
     }
 
@@ -215,7 +221,7 @@ pub fn message_info_rlp(vote_step: &VoteStep, block_hash: Option<BlockHash>) ->
     s.out()
 }
 
-pub fn message_full_rlp(signature: &H520, vote_info: &Bytes) -> Bytes {
+pub fn message_full_rlp(signature: &SignatureData, vote_info: &Bytes) -> Bytes {
     let mut s = RlpStream::new_list(2);
     s.append(signature).append_raw(vote_info, 1);
     s.out()

core/src/consensus/tendermint/mod.rs

@@ -23,9 +23,9 @@ use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrdering};
 use std::sync::{Arc, Weak};
 
 use ccrypto::blake256;
-use ckey::{public_to_address, recover, Message, Signature};
+use ckey::{public_to_address, recover, Message, Signature, SignatureData};
 use cnetwork::{Api, NetworkExtension, NodeId, TimerToken};
-use ctypes::{Address, Bytes, H256, H520, U128, U256};
+use ctypes::{Address, Bytes, H256, U128, U256};
 use parking_lot::{Mutex, RwLock};
 use rand::{thread_rng, Rng};
 use rlp::{self, Decodable, DecoderError, Encodable, RlpStream, UntrustedRlp};
@@ -749,7 +749,7 @@ where
         let mut addresses = HashSet::new();
         let ref header_signatures_field = header.seal().get(2).ok_or(BlockError::InvalidSeal)?;
         for rlp in UntrustedRlp::new(header_signatures_field).iter() {
-            let signature: H520 = rlp.as_val()?;
+            let signature: SignatureData = rlp.as_val()?;
             let address = (self.recover)(&signature.into(), &message)?;
 
             if !self.subchain_validators.contains(header.parent_hash(), &address) {

core/src/consensus/vote_collector.rs

@@ -18,14 +18,15 @@ use std::collections::{BTreeMap, HashMap, HashSet};
 use std::fmt::Debug;
 use std::hash::Hash;
 
-use ctypes::{Address, Bytes, H256, H520};
+use ckey::SignatureData;
+use ctypes::{Address, Bytes, H256};
 use parking_lot::RwLock;
 use rlp::{Encodable, RlpStream};
 
 pub trait Message: Clone + PartialEq + Eq + Hash + Encodable + Debug {
     type Round: Clone + PartialEq + Eq + Hash + Default + Debug + Ord;
 
-    fn signature(&self) -> H520;
+    fn signature(&self) -> SignatureData;
 
     fn block_hash(&self) -> Option<H256>;
 
@@ -43,7 +44,7 @@ pub struct VoteCollector<M: Message> {
 #[derive(Debug, Default)]
 struct StepCollector<M: Message> {
     voted: HashMap<Address, M>,
-    block_votes: HashMap<Option<H256>, HashMap<H520, Address>>,
+    block_votes: HashMap<Option<H256>, HashMap<SignatureData, Address>>,
     messages: HashSet<M>,
 }
 
@@ -136,7 +137,7 @@ impl<M: Message + Default + Encodable + Debug> VoteCollector<M> {
     }
 
     /// Collects the signatures for a given round and hash.
-    pub fn round_signatures(&self, round: &M::Round, block_hash: &H256) -> Vec<H520> {
+    pub fn round_signatures(&self, round: &M::Round, block_hash: &H256) -> Vec<SignatureData> {
         let guard = self.votes.read();
         guard
             .get(round)

key/src/ecdsa.rs

@@ -44,6 +44,8 @@ use super::{public_to_address, Address, Error, Message, Private, Public, SECP256
 
 pub const ECDSA_SIGNATURE_LENGTH: usize = 65;
 
+pub type ECDSASignatureData = H520;
+
 /// Signature encoded as RSV components
 #[repr(C)]
 pub struct ECDSASignature([u8; 65]);

key/src/lib.rs

@@ -43,7 +43,7 @@ use codechain_types::H256;
 #[cfg(feature = "ecdsa")]
 pub use ecdsa::{
     recover_ecdsa as recover, sign_ecdsa as sign, verify_ecdsa as verify, verify_ecdsa_address as verify_address,
-    ECDSASignature as Signature, ECDSA_SIGNATURE_LENGTH as SIGNATURE_LENGTH,
+    ECDSASignature as Signature, ECDSASignatureData as SignatureData, ECDSA_SIGNATURE_LENGTH as SIGNATURE_LENGTH,
 };
 pub use error::Error;
 pub use exchange::exchange;
@@ -55,7 +55,7 @@ pub use rustc_serialize::hex;
 #[cfg(feature = "schnorr")]
 pub use schnorr::{
     recover_schnorr as recover, sign_schnorr as sign, verify_schnorr as verify,
-    verify_schnorr_address as verify_address, SchnorrSignature as Signature,
+    verify_schnorr_address as verify_address, SchnorrSignature as Signature, SchnorrSignatureData as SignatureData,
     SCHNORR_SIGNATURE_LENGTH as SIGNATURE_LENGTH,
 };
 

key/src/schnorr.rs

@@ -28,6 +28,8 @@ use super::{public_to_address, Address, Error, Message, Private, Public, SECP256
 
 pub const SCHNORR_SIGNATURE_LENGTH: usize = 64;
 
+pub type SchnorrSignatureData = H512;
+
 pub struct SchnorrSignature([u8; 64]);
 
 // manual implementation large arrays don't have trait impls by default.

vm/src/executor.rs

@@ -15,8 +15,8 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 use ccrypto::{blake256, keccak256, ripemd160, sha256};
-use ckey::{verify, Signature, SIGNATURE_LENGTH};
-use ctypes::{H256, H520, Public};
+use ckey::{verify, Signature, SignatureData, SIGNATURE_LENGTH};
+use ctypes::{H256, Public};
 
 use instruction::{is_valid_unlock_script, Instruction};
 
@@ -209,7 +209,8 @@ pub fn execute(
             }
             Instruction::ChkSig => {
                 let pubkey = Public::from_slice(stack.pop()?.assert_len(64)?.as_ref());
-                let signature = Signature::from(H520::from(stack.pop()?.assert_len(SIGNATURE_LENGTH)?.as_ref()));
+                let signature =
+                    Signature::from(SignatureData::from(stack.pop()?.assert_len(SIGNATURE_LENGTH)?.as_ref()));
                 let result = match verify(&pubkey, &signature, &tx_hash) {
                     Ok(true) => 1,
                     _ => 0,

vm/src/tests/executor.rs

@@ -15,8 +15,8 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 use ccrypto::{blake256, BLAKE_EMPTY, BLAKE_NULL_RLP};
-use ckey::{sign, KeyPair, Private};
-use ctypes::{H160, H256, H520};
+use ckey::{sign, KeyPair, Private, SignatureData};
+use ctypes::{H160, H256};
 
 use secp256k1::key::{SecretKey, MINUS_ONE_KEY, ONE_KEY};
 
@@ -70,7 +70,7 @@ fn valid_pay_to_public_key() {
     let keypair = KeyPair::from_private(Private::from(SecretKey::from(ONE_KEY))).unwrap();
     let pubkey = <&[u8]>::from(keypair.public()).to_vec();
     let message = blake256("asdf");
-    let signature = H520::from(sign(keypair.private(), &message).unwrap()).to_vec();
+    let signature = SignatureData::from(sign(keypair.private(), &message).unwrap()).to_vec();
     let unlock_script = vec![Instruction::PushB(signature)];
     let lock_script = vec![Instruction::PushB(pubkey), Instruction::ChkSig];
 
@@ -85,7 +85,7 @@ fn invalid_pay_to_public_key() {
     let lock_script = vec![Instruction::PushB(pubkey), Instruction::ChkSig];
 
     let invalid_keypair = KeyPair::from_private(Private::from(SecretKey::from(MINUS_ONE_KEY))).unwrap();
-    let invalid_signature = H520::from(sign(invalid_keypair.private(), &message).unwrap()).to_vec();
+    let invalid_signature = SignatureData::from(sign(invalid_keypair.private(), &message).unwrap()).to_vec();
     let unlock_script = vec![Instruction::PushB(invalid_signature)];
 
     assert_eq!(execute(&unlock_script[..], &[], &lock_script, message, Config::default()), Ok(ScriptResult::Fail));