Replace Deref for hash to AsRef and AsMut

The new hashes will not implement `Deref`.

Author: Seulgi Kim

basic_module/account/src/lib.rs

@@ -37,7 +37,7 @@ pub fn check(signed_tx: &SignedTransaction) -> bool {
     let signature = signed_tx.signature;
     let network_id = signed_tx.tx.network_id;
 
-    check_network_id(network_id) && verify(&signature, &signed_tx.tx.hash(), &signed_tx.signer_public)
+    check_network_id(network_id) && verify(&signature, signed_tx.tx.hash().as_ref(), &signed_tx.signer_public)
 }
 
 fn check_network_id(network_id: NetworkId) -> bool {

basic_module/staking/src/transactions.rs

@@ -38,7 +38,7 @@ pub struct SignedTransaction {
 impl SignedTransaction {
     pub fn verify(&self) -> bool {
         let message = self.tx.hash();
-        verify(&self.signature, &message, &self.signer_public)
+        verify(&self.signature, message.as_ref(), &self.signer_public)
     }
 }
 

core/src/blockchain/blockchain.rs

@@ -62,7 +62,7 @@ fn get_or_insert_with<F: FnOnce() -> BlockHash>(db: &dyn KeyValueDB, key: &[u8],
             let hash = default();
 
             let mut batch = DBTransaction::new();
-            batch.put(db::COL_EXTRA, BEST_BLOCK_KEY, &hash);
+            batch.put(db::COL_EXTRA, BEST_BLOCK_KEY, hash.as_ref());
             db.write(batch).expect("Low level database error. Some issue with disk?");
             hash
         }
@@ -136,9 +136,9 @@ impl BlockChain {
             best_block: block.into_inner(),
         });
 
-        batch.put(db::COL_EXTRA, BEST_BLOCK_KEY, hash);
+        batch.put(db::COL_EXTRA, BEST_BLOCK_KEY, hash.as_ref());
         *self.pending_best_block_hash.write() = Some(*hash);
-        batch.put(db::COL_EXTRA, BEST_PROPOSAL_BLOCK_KEY, hash);
+        batch.put(db::COL_EXTRA, BEST_PROPOSAL_BLOCK_KEY, hash.as_ref());
         *self.pending_best_proposal_block_hash.write() = Some(*hash);
     }
 
@@ -178,11 +178,11 @@ impl BlockChain {
 
         if let Some(best_block_hash) = best_block_changed.new_best_hash() {
             let mut pending_best_block_hash = self.pending_best_block_hash.write();
-            batch.put(db::COL_EXTRA, BEST_BLOCK_KEY, &best_block_hash);
+            batch.put(db::COL_EXTRA, BEST_BLOCK_KEY, best_block_hash.as_ref());
             *pending_best_block_hash = Some(best_block_hash);
 
             let mut pending_best_proposal_block_hash = self.pending_best_proposal_block_hash.write();
-            batch.put(db::COL_EXTRA, BEST_PROPOSAL_BLOCK_KEY, &*new_block_hash);
+            batch.put(db::COL_EXTRA, BEST_PROPOSAL_BLOCK_KEY, new_block_hash.as_ref());
             *pending_best_proposal_block_hash = Some(new_block_hash);
         }
 
@@ -316,11 +316,11 @@ impl BlockChain {
         self.body_db.update_best_block(batch, &best_block_changed);
 
         let mut pending_best_block_hash = self.pending_best_block_hash.write();
-        batch.put(db::COL_EXTRA, BEST_BLOCK_KEY, &block_hash);
+        batch.put(db::COL_EXTRA, BEST_BLOCK_KEY, block_hash.as_ref());
         *pending_best_block_hash = Some(block_hash);
 
         let mut pending_best_proposal_block_hash = self.pending_best_proposal_block_hash.write();
-        batch.put(db::COL_EXTRA, BEST_PROPOSAL_BLOCK_KEY, &*block_hash);
+        batch.put(db::COL_EXTRA, BEST_PROPOSAL_BLOCK_KEY, block_hash.as_ref());
         *pending_best_proposal_block_hash = Some(block_hash);
 
         ChainUpdateResult::new(&best_block_changed)

core/src/blockchain/body_db.rs

@@ -55,7 +55,7 @@ impl BodyDB {
         let genesis_hash = genesis.hash();
         if bdb.block_body(&genesis_hash).is_none() {
             let mut batch = DBTransaction::new();
-            batch.put(db::COL_BODIES, &genesis_hash, &Self::block_to_body(genesis));
+            batch.put(db::COL_BODIES, genesis_hash.as_ref(), &Self::block_to_body(genesis));
 
             bdb.db.write(batch).expect("Low level database error. Some issue with disk?");
         }
@@ -76,7 +76,7 @@ impl BodyDB {
         let compressed_body = compress(&Self::block_to_body(block), blocks_swapper());
 
         // store block in db
-        batch.put(db::COL_BODIES, &hash, &compressed_body);
+        batch.put(db::COL_BODIES, hash.as_ref(), &compressed_body);
     }
 
     pub fn update_best_block(&self, batch: &mut DBTransaction, best_block_changed: &BestBlockChanged) {
@@ -164,7 +164,7 @@ impl BodyProvider for BodyDB {
 
         // Read from DB and populate cache
         let compressed_body =
-            self.db.get(db::COL_BODIES, hash).expect("Low level database error. Some issue with disk?")?;
+            self.db.get(db::COL_BODIES, hash.as_ref()).expect("Low level database error. Some issue with disk?")?;
 
         let raw_body = decompress(&compressed_body, blocks_swapper());
         let mut lock = self.body_cache.lock();

core/src/blockchain/extras.rs

@@ -18,7 +18,6 @@ use crate::db::Key;
 use crate::types::TransactionId;
 use ctypes::{BlockHash, BlockNumber, TransactionIndex, TxHash};
 use primitives::{H256, H264};
-use std::ops::Deref;
 
 /// Represents index of extra data in database
 #[derive(Copy, Debug, Hash, Eq, PartialEq, Clone)]
@@ -33,18 +32,16 @@ enum ExtrasIndex {
 
 fn with_index(hash: &H256, i: ExtrasIndex) -> H264 {
     let mut result = H264::default();
-    result[0] = i as u8;
-    (*result)[1..].copy_from_slice(hash);
+    result.as_mut()[0] = i as u8;
+    result.as_mut()[1..].copy_from_slice(hash.as_ref());
     result
 }
 
 pub struct BlockNumberKey([u8; 5]);
 
-impl Deref for BlockNumberKey {
-    type Target = [u8];
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
+impl AsRef<[u8]> for BlockNumberKey {
+    fn as_ref(&self) -> &[u8] {
+        self.0.as_ref()
     }
 }
 

core/src/blockchain/headerchain.rs

@@ -77,13 +77,13 @@ impl HeaderChain {
                 };
 
                 let mut batch = DBTransaction::new();
-                batch.put(db::COL_HEADERS, &hash, genesis.rlp().as_raw());
+                batch.put(db::COL_HEADERS, hash.as_ref(), genesis.rlp().as_raw());
 
                 batch.write(db::COL_EXTRA, &hash, &details);
                 batch.write(db::COL_EXTRA, &genesis.number(), &hash);
 
-                batch.put(db::COL_EXTRA, BEST_HEADER_KEY, &hash);
-                batch.put(db::COL_EXTRA, BEST_PROPOSAL_HEADER_KEY, &hash);
+                batch.put(db::COL_EXTRA, BEST_HEADER_KEY, hash.as_ref());
+                batch.put(db::COL_EXTRA, BEST_PROPOSAL_HEADER_KEY, hash.as_ref());
                 db.write(batch).expect("Low level database error. Some issue with disk?");
                 hash
             }
@@ -127,7 +127,7 @@ impl HeaderChain {
         }
 
         let compressed_header = compress(header.rlp().as_raw(), blocks_swapper());
-        batch.put(db::COL_HEADERS, &hash, &compressed_header);
+        batch.put(db::COL_HEADERS, hash.as_ref(), &compressed_header);
 
         let mut new_hashes = HashMap::new();
         new_hashes.insert(header.number(), hash);
@@ -151,9 +151,9 @@ impl HeaderChain {
         assert!(self.pending_best_header_hash.read().is_none());
         assert!(self.pending_best_proposal_block_hash.read().is_none());
 
-        batch.put(db::COL_EXTRA, BEST_HEADER_KEY, hash);
+        batch.put(db::COL_EXTRA, BEST_HEADER_KEY, hash.as_ref());
         *self.pending_best_header_hash.write() = Some(*hash);
-        batch.put(db::COL_EXTRA, BEST_PROPOSAL_HEADER_KEY, hash);
+        batch.put(db::COL_EXTRA, BEST_PROPOSAL_HEADER_KEY, hash.as_ref());
         *self.pending_best_proposal_block_hash.write() = Some(*hash);
     }
 
@@ -181,7 +181,7 @@ impl HeaderChain {
 
         // store block in db
         let compressed_header = compress(header.rlp().as_raw(), blocks_swapper());
-        batch.put(db::COL_HEADERS, &hash, &compressed_header);
+        batch.put(db::COL_HEADERS, hash.as_ref(), &compressed_header);
 
         let best_header_changed = self.best_header_changed(header, engine);
 
@@ -191,10 +191,10 @@ impl HeaderChain {
         let mut pending_best_header_hash = self.pending_best_header_hash.write();
         let mut pending_best_proposal_header_hash = self.pending_best_proposal_block_hash.write();
         if let Some(best_block_hash) = best_header_changed.new_best_hash() {
-            batch.put(db::COL_EXTRA, BEST_HEADER_KEY, &best_block_hash);
+            batch.put(db::COL_EXTRA, BEST_HEADER_KEY, best_block_hash.as_ref());
             *pending_best_header_hash = Some(best_block_hash);
 
-            batch.put(db::COL_EXTRA, BEST_PROPOSAL_HEADER_KEY, &hash);
+            batch.put(db::COL_EXTRA, BEST_PROPOSAL_HEADER_KEY, hash.as_ref());
             *pending_best_proposal_header_hash = Some(hash);
         }
 
@@ -344,11 +344,11 @@ impl HeaderChain {
         new_hashes.insert(block_detail.number, block_hash);
 
         let mut pending_best_header_hash = self.pending_best_header_hash.write();
-        batch.put(db::COL_EXTRA, BEST_HEADER_KEY, &block_hash);
+        batch.put(db::COL_EXTRA, BEST_HEADER_KEY, block_hash.as_ref());
         *pending_best_header_hash = Some(block_hash);
 
         let mut pending_best_proposal_block_hash = self.pending_best_proposal_block_hash.write();
-        batch.put(db::COL_EXTRA, BEST_PROPOSAL_HEADER_KEY, &block_hash);
+        batch.put(db::COL_EXTRA, BEST_PROPOSAL_HEADER_KEY, block_hash.as_ref());
         *pending_best_proposal_block_hash = Some(block_hash);
 
         let mut pending_hashes = self.pending_hashes.write();
@@ -454,7 +454,7 @@ fn block_header_data(
         }
     }
     // Read from DB and populate cache
-    let b = db.get(db::COL_HEADERS, hash).expect("Low level database error. Some issue with disk?")?;
+    let b = db.get(db::COL_HEADERS, hash.as_ref()).expect("Low level database error. Some issue with disk?")?;
 
     let bytes = decompress(&b, blocks_swapper());
 

core/src/consensus/tendermint/engine.rs

@@ -138,7 +138,7 @@ impl ConsensusEngine for Tendermint {
             }
             let public = validator_set[bitset_index].public_key;
             let delegation = validator_set[bitset_index].delegation;
-            if !verify(&signature, &precommit_vote_on.hash(), &public) {
+            if !verify(&signature, precommit_vote_on.hash().as_ref(), &public) {
                 return Err(EngineError::BlockNotAuthorized(public).into())
             }
             signed_delegation += delegation;

core/src/consensus/tendermint/message.rs

@@ -373,7 +373,7 @@ impl ConsensusMessage {
     }
 
     pub fn verify(&self, signer_public: &Public) -> bool {
-        verify(&self.signature, &self.on.hash(), signer_public)
+        verify(&self.signature, self.on.hash().as_ref(), signer_public)
     }
 }
 

core/src/consensus/tendermint/worker.rs

@@ -1223,7 +1223,7 @@ impl Worker {
         let parent_hash = header.parent_hash();
         for (bitset_index, signature) in seal_view.signatures()? {
             let public = self.validators.get_current(header.parent_hash(), bitset_index);
-            if !verify(&signature, &precommit_vote_on.hash(), &public) {
+            if !verify(&signature, precommit_vote_on.hash().as_ref(), &public) {
                 return Err(EngineError::BlockNotAuthorized(public).into())
             }
             assert!(!voted_validators.is_set(bitset_index), "Double vote");

core/src/db.rs

@@ -18,7 +18,6 @@ use kvdb::{DBTransaction, KeyValueDB};
 use parking_lot::RwLock;
 use std::collections::HashMap;
 use std::hash::Hash;
-use std::ops::Deref;
 
 // database columns
 /// Column for State
@@ -77,7 +76,7 @@ where
 /// Should be used to get database key associated with given value.
 pub trait Key<T> {
     /// The db key associated with this value.
-    type Target: Deref<Target = [u8]>;
+    type Target: AsRef<[u8]>;
 
     /// Returns db key.
     fn key(&self) -> Self::Target;
@@ -89,13 +88,13 @@ pub trait Writable {
     fn write<T, R>(&mut self, col: Option<u32>, key: &dyn Key<T, Target = R>, value: &T)
     where
         T: rlp::Encodable,
-        R: Deref<Target = [u8]>;
+        R: AsRef<[u8]>;
 
     /// Deletes key from the databse.
     fn delete<T, R>(&mut self, col: Option<u32>, key: &dyn Key<T, Target = R>)
     where
         T: rlp::Encodable,
-        R: Deref<Target = [u8]>;
+        R: AsRef<[u8]>;
 
     /// Writes the value into the database and updates the cache.
     fn write_with_cache<K, T, R>(
@@ -108,7 +107,7 @@ pub trait Writable {
     ) where
         K: Key<T, Target = R> + Hash + Eq,
         T: rlp::Encodable,
-        R: Deref<Target = [u8]>, {
+        R: AsRef<[u8]>, {
         self.write(col, &key, &value);
         match policy {
             CacheUpdatePolicy::Overwrite => {
@@ -130,7 +129,7 @@ pub trait Writable {
     ) where
         K: Key<T, Target = R> + Hash + Eq,
         T: rlp::Encodable,
-        R: Deref<Target = [u8]>, {
+        R: AsRef<[u8]>, {
         match policy {
             CacheUpdatePolicy::Overwrite => {
                 for (key, value) in values {
@@ -154,7 +153,7 @@ pub trait Readable {
     fn read<T, R>(&self, col: Option<u32>, key: &dyn Key<T, Target = R>) -> Option<T>
     where
         T: rlp::Decodable,
-        R: Deref<Target = [u8]>;
+        R: AsRef<[u8]>;
 
     /// Returns value for given key either in cache or in database.
     fn read_with_cache<K, T, C>(&self, col: Option<u32>, cache: &mut C, key: &K) -> Option<T>
@@ -177,13 +176,13 @@ pub trait Readable {
     /// Returns true if given value exists.
     fn exists<T, R>(&self, col: Option<u32>, key: &dyn Key<T, Target = R>) -> bool
     where
-        R: Deref<Target = [u8]>;
+        R: AsRef<[u8]>;
 
     /// Returns true if given value exists either in cache or in database.
     fn exists_with_cache<K, T, R, C>(&self, col: Option<u32>, cache: &RwLock<C>, key: &K) -> bool
     where
         K: Eq + Hash + Key<T, Target = R>,
-        R: Deref<Target = [u8]>,
+        R: AsRef<[u8]>,
         C: Cache<K, T>, {
         {
             let read = cache.read();
@@ -200,42 +199,42 @@ impl Writable for DBTransaction {
     fn write<T, R>(&mut self, col: Option<u32>, key: &dyn Key<T, Target = R>, value: &T)
     where
         T: rlp::Encodable,
-        R: Deref<Target = [u8]>, {
-        self.put(col, &key.key(), &rlp::encode(value));
+        R: AsRef<[u8]>, {
+        self.put(col, key.key().as_ref(), &rlp::encode(value));
     }
 
     fn delete<T, R>(&mut self, col: Option<u32>, key: &dyn Key<T, Target = R>)
     where
         T: rlp::Encodable,
-        R: Deref<Target = [u8]>, {
-        self.delete(col, &key.key());
+        R: AsRef<[u8]>, {
+        self.delete(col, key.key().as_ref());
     }
 }
 
 impl<KVDB: KeyValueDB + ?Sized> Readable for KVDB {
     fn read<T, R>(&self, col: Option<u32>, key: &dyn Key<T, Target = R>) -> Option<T>
     where
         T: rlp::Decodable,
-        R: Deref<Target = [u8]>, {
-        let result = self.get(col, &key.key());
+        R: AsRef<[u8]>, {
+        let result = self.get(col, key.key().as_ref());
 
         match result {
             Ok(option) => option.map(|v| rlp::decode(&v).unwrap()),
             Err(err) => {
-                panic!("db get failed, key: {:?}, err: {:?}", &key.key() as &[u8], err);
+                panic!("db get failed, key: {:?}, err: {:?}", key.key().as_ref(), err);
             }
         }
     }
 
     fn exists<T, R>(&self, col: Option<u32>, key: &dyn Key<T, Target = R>) -> bool
     where
-        R: Deref<Target = [u8]>, {
-        let result = self.get(col, &key.key());
+        R: AsRef<[u8]>, {
+        let result = self.get(col, key.key().as_ref());
 
         match result {
             Ok(v) => v.is_some(),
             Err(err) => {
-                panic!("db get failed, key: {:?}, err: {:?}", &key.key() as &[u8], err);
+                panic!("db get failed, key: {:?}, err: {:?}", key.key().as_ref(), err);
             }
         }
     }