Distinguish TxHash from H256

Author: Seulgi Kim

core/src/block.rs

@@ -23,7 +23,7 @@ use cstate::{FindActionHandler, StateDB, StateError, StateWithCache, TopLevelSta
 use ctypes::errors::HistoryError;
 use ctypes::header::{Header, Seal};
 use ctypes::util::unexpected::Mismatch;
-use ctypes::{BlockNumber, CommonParams};
+use ctypes::{BlockNumber, CommonParams, TxHash};
 use cvm::ChainTimeInfo;
 use primitives::{Bytes, H256};
 use rlp::{Decodable, DecoderError, Encodable, RlpStream, UntrustedRlp};
@@ -90,7 +90,7 @@ pub struct ExecutedBlock {
     state: TopLevelState,
     transactions: Vec<SignedTransaction>,
     invoices: Vec<Invoice>,
-    transactions_set: HashSet<H256>,
+    transactions_set: HashSet<TxHash>,
 }
 
 impl ExecutedBlock {
@@ -153,7 +153,7 @@ impl<'x> OpenBlock<'x> {
     pub fn push_transaction<C: ChainTimeInfo + FindActionHandler>(
         &mut self,
         tx: SignedTransaction,
-        h: Option<H256>,
+        h: Option<TxHash>,
         client: &C,
         parent_block_number: BlockNumber,
         parent_block_timestamp: u64,

core/src/blockchain/blockchain.rs

@@ -16,7 +16,7 @@
 
 use std::sync::Arc;
 
-use ctypes::{BlockHash, BlockNumber, Tracker};
+use ctypes::{BlockHash, BlockNumber, Tracker, TxHash};
 use kvdb::{DBTransaction, KeyValueDB};
 use parking_lot::RwLock;
 use primitives::H256;
@@ -411,7 +411,7 @@ impl BodyProvider for BlockChain {
         self.body_db.is_known_body(hash)
     }
 
-    fn transaction_address(&self, hash: &H256) -> Option<TransactionAddress> {
+    fn transaction_address(&self, hash: &TxHash) -> Option<TransactionAddress> {
         self.body_db.transaction_address(hash)
     }
 
@@ -426,15 +426,15 @@ impl BodyProvider for BlockChain {
 
 impl InvoiceProvider for BlockChain {
     /// Returns true if invoices for given hash is known
-    fn is_known_error_hint(&self, hash: &H256) -> bool {
+    fn is_known_error_hint(&self, hash: &TxHash) -> bool {
         self.invoice_db.is_known_error_hint(hash)
     }
 
-    fn error_hints_by_tracker(&self, tracker: &Tracker) -> Vec<(H256, Option<String>)> {
+    fn error_hints_by_tracker(&self, tracker: &Tracker) -> Vec<(TxHash, Option<String>)> {
         self.invoice_db.error_hints_by_tracker(tracker)
     }
 
-    fn error_hint(&self, hash: &H256) -> Option<String> {
+    fn error_hint(&self, hash: &TxHash) -> Option<String> {
         self.invoice_db.error_hint(hash)
     }
 }

core/src/blockchain/body_db.rs

@@ -18,11 +18,11 @@ use std::collections::{HashMap, HashSet};
 use std::mem;
 use std::sync::Arc;
 
-use ctypes::{BlockHash, Tracker};
+use ctypes::{BlockHash, Tracker, TxHash};
 use kvdb::{DBTransaction, KeyValueDB};
 use lru_cache::LruCache;
 use parking_lot::{Mutex, RwLock};
-use primitives::{Bytes, H256};
+use primitives::Bytes;
 use rlp::RlpStream;
 use rlp_compress::{blocks_swapper, compress, decompress};
 
@@ -37,8 +37,8 @@ const BODY_CACHE_SIZE: usize = 1000;
 pub struct BodyDB {
     // block cache
     body_cache: Mutex<LruCache<BlockHash, Bytes>>,
-    parcel_address_cache: RwLock<HashMap<H256, TransactionAddress>>,
-    pending_parcel_addresses: RwLock<HashMap<H256, Option<TransactionAddress>>>,
+    parcel_address_cache: RwLock<HashMap<TxHash, TransactionAddress>>,
+    pending_parcel_addresses: RwLock<HashMap<TxHash, Option<TransactionAddress>>>,
 
     transaction_address_cache: Mutex<HashMap<Tracker, TransactionAddresses>>,
     pending_transaction_addresses: Mutex<HashMap<Tracker, Option<TransactionAddresses>>>,
@@ -141,7 +141,7 @@ impl BodyDB {
     fn new_parcel_address_entries(
         &self,
         best_block_changed: &BestBlockChanged,
-    ) -> HashMap<H256, Option<TransactionAddress>> {
+    ) -> HashMap<TxHash, Option<TransactionAddress>> {
         let block_hash = if let Some(best_block_hash) = best_block_changed.new_best_hash() {
             best_block_hash
         } else {
@@ -284,7 +284,7 @@ pub trait BodyProvider {
     fn is_known_body(&self, hash: &BlockHash) -> bool;
 
     /// Get the address of parcel with given hash.
-    fn transaction_address(&self, hash: &H256) -> Option<TransactionAddress>;
+    fn transaction_address(&self, hash: &TxHash) -> Option<TransactionAddress>;
 
     fn transaction_address_by_tracker(&self, tracker: &Tracker) -> Option<TransactionAddress>;
 
@@ -298,7 +298,7 @@ impl BodyProvider for BodyDB {
     }
 
     /// Get the address of parcel with given hash.
-    fn transaction_address(&self, hash: &H256) -> Option<TransactionAddress> {
+    fn transaction_address(&self, hash: &TxHash) -> Option<TransactionAddress> {
         let result = self.db.read_with_cache(db::COL_EXTRA, &mut *self.parcel_address_cache.write(), hash)?;
         Some(result)
     }
@@ -332,11 +332,11 @@ impl BodyProvider for BodyDB {
 
 fn parcel_address_entries(
     block_hash: BlockHash,
-    parcel_hashes: impl IntoIterator<Item = H256>,
-) -> impl Iterator<Item = (H256, Option<TransactionAddress>)> {
-    parcel_hashes.into_iter().enumerate().map(move |(index, parcel_hash)| {
+    tx_hashes: impl IntoIterator<Item = TxHash>,
+) -> impl Iterator<Item = (TxHash, Option<TransactionAddress>)> {
+    tx_hashes.into_iter().enumerate().map(move |(index, tx_hash)| {
         (
-            parcel_hash,
+            tx_hash,
             Some(TransactionAddress {
                 block_hash,
                 index,

core/src/blockchain/extras.rs

@@ -16,7 +16,7 @@
 
 use std::ops::{Add, AddAssign, Deref, Sub, SubAssign};
 
-use ctypes::{BlockHash, BlockNumber, Tracker};
+use ctypes::{BlockHash, BlockNumber, Tracker, TxHash};
 use primitives::{H256, H264, U256};
 
 use crate::db::Key;
@@ -29,8 +29,8 @@ enum ExtrasIndex {
     BlockDetails = 0,
     /// Block hash index
     BlockHash = 1,
-    /// Parcel address index
-    ParcelAddress = 2,
+    /// Transaction address index
+    TransactionAddress = 2,
     /// Transaction addresses index
     TransactionAddresses = 3,
     // (Reserved) = 4,
@@ -77,11 +77,11 @@ impl Key<BlockDetails> for BlockHash {
     }
 }
 
-impl Key<TransactionAddress> for H256 {
+impl Key<TransactionAddress> for TxHash {
     type Target = H264;
 
     fn key(&self) -> H264 {
-        with_index(self, ExtrasIndex::ParcelAddress)
+        with_index(self, ExtrasIndex::TransactionAddress)
     }
 }
 

core/src/blockchain/invoice_db.rs

@@ -18,7 +18,7 @@ use std::collections::HashMap;
 use std::ops::{Deref, DerefMut};
 use std::sync::Arc;
 
-use ctypes::Tracker;
+use ctypes::{Tracker, TxHash};
 use kvdb::{DBTransaction, KeyValueDB};
 use parking_lot::RwLock;
 use primitives::{H256, H264};
@@ -33,7 +33,7 @@ pub struct InvoiceDB {
     // tracker -> transaction hashe + error hint
     tracker_cache: RwLock<HashMap<Tracker, TrackerInvoices>>,
     // transaction hash -> error hint
-    hash_cache: RwLock<HashMap<H256, Option<String>>>,
+    hash_cache: RwLock<HashMap<TxHash, Option<String>>>,
 
     db: Arc<dyn KeyValueDB>,
 }
@@ -55,7 +55,7 @@ impl InvoiceDB {
     pub fn insert_invoice(
         &self,
         batch: &mut DBTransaction,
-        hash: H256,
+        hash: TxHash,
         tracker: Option<Tracker>,
         error_hint: Option<String>,
     ) {
@@ -80,34 +80,34 @@ impl InvoiceDB {
 /// Interface for querying invoices.
 pub trait InvoiceProvider {
     /// Returns true if invoices for given hash is known
-    fn is_known_error_hint(&self, hash: &H256) -> bool;
+    fn is_known_error_hint(&self, hash: &TxHash) -> bool;
 
     /// Get error hints
-    fn error_hints_by_tracker(&self, tracker: &Tracker) -> Vec<(H256, Option<String>)>;
+    fn error_hints_by_tracker(&self, tracker: &Tracker) -> Vec<(TxHash, Option<String>)>;
 
     /// Get error hint
-    fn error_hint(&self, hash: &H256) -> Option<String>;
+    fn error_hint(&self, hash: &TxHash) -> Option<String>;
 }
 
 impl InvoiceProvider for InvoiceDB {
-    fn is_known_error_hint(&self, hash: &H256) -> bool {
+    fn is_known_error_hint(&self, hash: &TxHash) -> bool {
         self.db.exists_with_cache(db::COL_ERROR_HINT, &self.hash_cache, hash)
     }
 
-    fn error_hints_by_tracker(&self, tracker: &Tracker) -> Vec<(H256, Option<String>)> {
+    fn error_hints_by_tracker(&self, tracker: &Tracker) -> Vec<(TxHash, Option<String>)> {
         self.db
             .read_with_cache(db::COL_ERROR_HINT, &mut *self.tracker_cache.write(), tracker)
             .map(|hashes| (*hashes).clone())
             .unwrap_or_default()
     }
 
-    fn error_hint(&self, hash: &H256) -> Option<String> {
+    fn error_hint(&self, hash: &TxHash) -> Option<String> {
         self.db.read_with_cache(db::COL_ERROR_HINT, &mut *self.hash_cache.write(), hash)?
     }
 }
 
 #[derive(Clone, Default)]
-pub struct TrackerInvoices(Vec<(H256, Option<String>)>);
+pub struct TrackerInvoices(Vec<(TxHash, Option<String>)>);
 
 impl Encodable for TrackerInvoices {
     fn rlp_append(&self, s: &mut RlpStream) {
@@ -137,14 +137,14 @@ impl Decodable for TrackerInvoices {
     }
 }
 
-impl From<Vec<(H256, Option<String>)>> for TrackerInvoices {
-    fn from(f: Vec<(H256, Option<String>)>) -> Self {
+impl From<Vec<(TxHash, Option<String>)>> for TrackerInvoices {
+    fn from(f: Vec<(TxHash, Option<String>)>) -> Self {
         TrackerInvoices(f)
     }
 }
 
 impl Deref for TrackerInvoices {
-    type Target = Vec<(H256, Option<String>)>;
+    type Target = Vec<(TxHash, Option<String>)>;
 
     fn deref(&self) -> &Self::Target {
         &self.0
@@ -168,7 +168,7 @@ impl From<ErrorHintIndex> for u8 {
     }
 }
 
-impl Key<Option<String>> for H256 {
+impl Key<Option<String>> for TxHash {
     type Target = H264;
 
     fn key(&self) -> H264 {

core/src/client/chain_notify.rs

@@ -15,8 +15,7 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 use cnetwork::NodeId;
-use ctypes::BlockHash;
-use primitives::H256;
+use ctypes::{BlockHash, TxHash};
 
 /// Represents what has to be handled by actor listening to chain events
 pub trait ChainNotify: Send + Sync {
@@ -48,7 +47,7 @@ pub trait ChainNotify: Send + Sync {
     }
 
     /// fires when new transactions are received from a peer
-    fn transactions_received(&self, _hashes: Vec<H256>, _peer_id: NodeId) {
+    fn transactions_received(&self, _hashes: Vec<TxHash>, _peer_id: NodeId) {
         // does nothing by default
     }
 }

core/src/client/client.rs

@@ -28,7 +28,7 @@ use cstate::{
 };
 use ctimer::{TimeoutHandler, TimerApi, TimerScheduleError, TimerToken};
 use ctypes::transaction::{AssetTransferInput, PartialHashing, ShardTransaction};
-use ctypes::{BlockHash, BlockNumber, CommonParams, ShardId, Tracker};
+use ctypes::{BlockHash, BlockNumber, CommonParams, ShardId, Tracker, TxHash};
 use cvm::{decode, execute, ChainTimeInfo, ScriptResult, VMConfig};
 use hashdb::AsHashDB;
 use journaldb;
@@ -142,7 +142,7 @@ impl Client {
         self.notify.write().push(target);
     }
 
-    pub fn transactions_received(&self, hashes: &[H256], peer_id: NodeId) {
+    pub fn transactions_received(&self, hashes: &[TxHash], peer_id: NodeId) {
         self.notify(|notify| {
             notify.transactions_received(hashes.to_vec(), peer_id);
         });
@@ -422,7 +422,7 @@ impl AssetClient for Client {
 }
 
 impl TextClient for Client {
-    fn get_text(&self, tx_hash: H256, id: BlockId) -> TrieResult<Option<Text>> {
+    fn get_text(&self, tx_hash: TxHash, id: BlockId) -> TrieResult<Option<Text>> {
         if let Some(state) = Client::state_at(&self, id) {
             Ok(state.text(&tx_hash)?)
         } else {
@@ -797,7 +797,7 @@ impl BlockChainClient for Client {
         self.transaction_address(id).and_then(|address| chain.transaction(&address))
     }
 
-    fn error_hint(&self, hash: &H256) -> Option<String> {
+    fn error_hint(&self, hash: &TxHash) -> Option<String> {
         let chain = self.block_chain();
         chain.error_hint(hash)
     }
@@ -808,7 +808,7 @@ impl BlockChainClient for Client {
         address.and_then(|address| chain.transaction(&address))
     }
 
-    fn error_hints_by_tracker(&self, tracker: &Tracker) -> Vec<(H256, Option<String>)> {
+    fn error_hints_by_tracker(&self, tracker: &Tracker) -> Vec<(TxHash, Option<String>)> {
         let chain = self.block_chain();
         chain.error_hints_by_tracker(tracker)
     }
@@ -855,7 +855,7 @@ impl Shard for Client {
         state.number_of_shards().ok()
     }
 
-    fn shard_id_by_hash(&self, create_shard_tx_hash: &H256, state: StateOrBlock) -> Option<u16> {
+    fn shard_id_by_hash(&self, create_shard_tx_hash: &TxHash, state: StateOrBlock) -> Option<u16> {
         let state = self.state_info(state)?;
         state.shard_id_by_hash(&create_shard_tx_hash).ok()?
     }

core/src/client/mod.rs

@@ -37,7 +37,7 @@ use cmerkle::Result as TrieResult;
 use cnetwork::NodeId;
 use cstate::{AssetScheme, FindActionHandler, OwnedAsset, StateResult, Text, TopLevelState, TopStateView};
 use ctypes::transaction::{AssetTransferInput, PartialHashing, ShardTransaction};
-use ctypes::{BlockHash, BlockNumber, CommonParams, ShardId, Tracker};
+use ctypes::{BlockHash, BlockNumber, CommonParams, ShardId, Tracker, TxHash};
 use cvm::ChainTimeInfo;
 use kvdb::KeyValueDB;
 use primitives::{Bytes, H160, H256, U256};
@@ -185,7 +185,7 @@ impl From<BlockId> for StateOrBlock {
 pub trait Shard {
     fn number_of_shards(&self, state: StateOrBlock) -> Option<ShardId>;
 
-    fn shard_id_by_hash(&self, create_shard_tx_hash: &H256, state: StateOrBlock) -> Option<ShardId>;
+    fn shard_id_by_hash(&self, create_shard_tx_hash: &TxHash, state: StateOrBlock) -> Option<ShardId>;
     fn shard_root(&self, shard_id: ShardId, state: StateOrBlock) -> Option<H256>;
 
     fn shard_owners(&self, shard_id: ShardId, state: StateOrBlock) -> Option<Vec<Address>>;
@@ -250,12 +250,12 @@ pub trait BlockChainClient: Sync + Send + AccountData + BlockChainTrait + Import
     fn transaction(&self, id: &TransactionId) -> Option<LocalizedTransaction>;
 
     /// Get invoice with given hash.
-    fn error_hint(&self, hash: &H256) -> Option<String>;
+    fn error_hint(&self, hash: &TxHash) -> Option<String>;
 
     /// Get the transaction with given tracker.
     fn transaction_by_tracker(&self, tracker: &Tracker) -> Option<LocalizedTransaction>;
 
-    fn error_hints_by_tracker(&self, tracker: &Tracker) -> Vec<(H256, Option<String>)>;
+    fn error_hints_by_tracker(&self, tracker: &Tracker) -> Vec<(TxHash, Option<String>)>;
 }
 
 /// Result of import block operation.
@@ -319,7 +319,7 @@ pub trait AssetClient {
 
 /// Provides methods to texts
 pub trait TextClient {
-    fn get_text(&self, tx_hash: H256, id: BlockId) -> TrieResult<Option<Text>>;
+    fn get_text(&self, tx_hash: TxHash, id: BlockId) -> TrieResult<Option<Text>>;
 }
 
 pub trait ExecuteClient: ChainTimeInfo {