Distinguish Tracker from H256

And rename some variables that was misnamed as tx_hash.

Author: Seulgi Kim

core/src/blockchain/blockchain.rs

@@ -16,7 +16,7 @@
 
 use std::sync::Arc;
 
-use ctypes::{BlockHash, BlockNumber};
+use ctypes::{BlockHash, BlockNumber, Tracker};
 use kvdb::{DBTransaction, KeyValueDB};
 use parking_lot::RwLock;
 use primitives::H256;
@@ -415,7 +415,7 @@ impl BodyProvider for BlockChain {
         self.body_db.transaction_address(hash)
     }
 
-    fn transaction_address_by_tracker(&self, tracker: &H256) -> Option<TransactionAddress> {
+    fn transaction_address_by_tracker(&self, tracker: &Tracker) -> Option<TransactionAddress> {
         self.body_db.transaction_address_by_tracker(tracker)
     }
 
@@ -430,7 +430,7 @@ impl InvoiceProvider for BlockChain {
         self.invoice_db.is_known_error_hint(hash)
     }
 
-    fn error_hints_by_tracker(&self, tracker: &H256) -> Vec<(H256, Option<String>)> {
+    fn error_hints_by_tracker(&self, tracker: &Tracker) -> Vec<(H256, Option<String>)> {
         self.invoice_db.error_hints_by_tracker(tracker)
     }
 

core/src/blockchain/body_db.rs

@@ -18,7 +18,7 @@ use std::collections::{HashMap, HashSet};
 use std::mem;
 use std::sync::Arc;
 
-use ctypes::BlockHash;
+use ctypes::{BlockHash, Tracker};
 use kvdb::{DBTransaction, KeyValueDB};
 use lru_cache::LruCache;
 use parking_lot::{Mutex, RwLock};
@@ -40,13 +40,13 @@ pub struct BodyDB {
     parcel_address_cache: RwLock<HashMap<H256, TransactionAddress>>,
     pending_parcel_addresses: RwLock<HashMap<H256, Option<TransactionAddress>>>,
 
-    transaction_address_cache: Mutex<HashMap<H256, TransactionAddresses>>,
-    pending_transaction_addresses: Mutex<HashMap<H256, Option<TransactionAddresses>>>,
+    transaction_address_cache: Mutex<HashMap<Tracker, TransactionAddresses>>,
+    pending_transaction_addresses: Mutex<HashMap<Tracker, Option<TransactionAddresses>>>,
 
     db: Arc<dyn KeyValueDB>,
 }
 
-type TransactionHashAndAddress = (H256, TransactionAddresses);
+type TrackerAndAddress = (Tracker, TransactionAddresses);
 
 impl BodyDB {
     /// Create new instance of blockchain from given Genesis.
@@ -185,7 +185,7 @@ impl BodyDB {
     fn new_transaction_address_entries(
         &self,
         best_block_changed: &BestBlockChanged,
-    ) -> HashMap<H256, Option<TransactionAddresses>> {
+    ) -> HashMap<Tracker, Option<TransactionAddresses>> {
         let block_hash = if let Some(best_block_hash) = best_block_changed.new_best_hash() {
             best_block_hash
         } else {
@@ -197,8 +197,8 @@ impl BodyDB {
         };
 
         let (removed, added): (
-            Box<dyn Iterator<Item = TransactionHashAndAddress>>,
-            Box<dyn Iterator<Item = TransactionHashAndAddress>>,
+            Box<dyn Iterator<Item = TrackerAndAddress>>,
+            Box<dyn Iterator<Item = TrackerAndAddress>>,
         ) = match best_block_changed {
             BestBlockChanged::CanonChainAppended {
                 ..
@@ -229,31 +229,31 @@ impl BodyDB {
             BestBlockChanged::None => return Default::default(),
         };
 
-        let mut added_addresses: HashMap<H256, TransactionAddresses> = Default::default();
-        let mut removed_addresses: HashMap<H256, TransactionAddresses> = Default::default();
-        let mut hashes: HashSet<H256> = Default::default();
-        for (hash, address) in added {
-            hashes.insert(hash);
-            *added_addresses.entry(hash).or_insert_with(Default::default) += address;
+        let mut added_addresses: HashMap<Tracker, TransactionAddresses> = Default::default();
+        let mut removed_addresses: HashMap<Tracker, TransactionAddresses> = Default::default();
+        let mut trackers: HashSet<Tracker> = Default::default();
+        for (tracker, address) in added {
+            trackers.insert(tracker);
+            *added_addresses.entry(tracker).or_insert_with(Default::default) += address;
         }
-        for (hash, address) in removed {
-            hashes.insert(hash);
-            *removed_addresses.entry(hash).or_insert_with(Default::default) += address;
+        for (tracker, address) in removed {
+            trackers.insert(tracker);
+            *removed_addresses.entry(tracker).or_insert_with(Default::default) += address;
         }
-        let mut inserted_address: HashMap<H256, TransactionAddresses> = Default::default();
-        for hash in hashes.into_iter() {
-            let address: TransactionAddresses = self.db.read(db::COL_EXTRA, &hash).unwrap_or_default();
-            inserted_address.insert(hash, address);
+        let mut inserted_address: HashMap<Tracker, TransactionAddresses> = Default::default();
+        for tracker in trackers.into_iter() {
+            let address: TransactionAddresses = self.db.read(db::COL_EXTRA, &tracker).unwrap_or_default();
+            inserted_address.insert(tracker, address);
         }
 
-        for (hash, removed_address) in removed_addresses.into_iter() {
+        for (tracker, removed_address) in removed_addresses.into_iter() {
             *inserted_address
-                .get_mut(&hash)
+                .get_mut(&tracker)
                 .expect("inserted addresses are sum of added_addresses and removed_addresses") -= removed_address;
         }
-        for (hash, added_address) in added_addresses.into_iter() {
+        for (tracker, added_address) in added_addresses.into_iter() {
             *inserted_address
-                .get_mut(&hash)
+                .get_mut(&tracker)
                 .expect("inserted addresses are sum of added_addresses and removed_addresses") += added_address;
         }
 
@@ -286,7 +286,7 @@ pub trait BodyProvider {
     /// Get the address of parcel with given hash.
     fn transaction_address(&self, hash: &H256) -> Option<TransactionAddress>;
 
-    fn transaction_address_by_tracker(&self, tracker: &H256) -> Option<TransactionAddress>;
+    fn transaction_address_by_tracker(&self, tracker: &Tracker) -> Option<TransactionAddress>;
 
     /// Get the block body (uncles and parcels).
     fn block_body(&self, hash: &BlockHash) -> Option<encoded::Body>;
@@ -303,7 +303,7 @@ impl BodyProvider for BodyDB {
         Some(result)
     }
 
-    fn transaction_address_by_tracker(&self, tracker: &H256) -> Option<TransactionAddress> {
+    fn transaction_address_by_tracker(&self, tracker: &Tracker) -> Option<TransactionAddress> {
         let addresses = self.db.read_with_cache(db::COL_EXTRA, &mut *self.transaction_address_cache.lock(), tracker)?;
         addresses.into_iter().next()
     }
@@ -348,7 +348,7 @@ fn parcel_address_entries(
 fn transaction_address_entries(
     block_hash: BlockHash,
     parcel_hashes: impl IntoIterator<Item = UnverifiedTransaction>,
-) -> impl Iterator<Item = TransactionHashAndAddress> {
+) -> impl Iterator<Item = TrackerAndAddress> {
     parcel_hashes.into_iter().enumerate().filter_map(move |(parcel_index, parcel)| {
         parcel.tracker().map(|tracker| {
             (

core/src/blockchain/extras.rs

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

core/src/blockchain/invoice_db.rs

@@ -18,6 +18,7 @@ use std::collections::HashMap;
 use std::ops::{Deref, DerefMut};
 use std::sync::Arc;
 
+use ctypes::Tracker;
 use kvdb::{DBTransaction, KeyValueDB};
 use parking_lot::RwLock;
 use primitives::{H256, H264};
@@ -30,7 +31,7 @@ use crate::db::{self, CacheUpdatePolicy, Key, Readable, Writable};
 /// **Does not do input data verification.**
 pub struct InvoiceDB {
     // tracker -> transaction hashe + error hint
-    tracker_cache: RwLock<HashMap<H256, TrackerInvoices>>,
+    tracker_cache: RwLock<HashMap<Tracker, TrackerInvoices>>,
     // transaction hash -> error hint
     hash_cache: RwLock<HashMap<H256, Option<String>>>,
 
@@ -55,7 +56,7 @@ impl InvoiceDB {
         &self,
         batch: &mut DBTransaction,
         hash: H256,
-        tracker: Option<H256>,
+        tracker: Option<Tracker>,
         error_hint: Option<String>,
     ) {
         if self.is_known_error_hint(&hash) {
@@ -82,7 +83,7 @@ pub trait InvoiceProvider {
     fn is_known_error_hint(&self, hash: &H256) -> bool;
 
     /// Get error hints
-    fn error_hints_by_tracker(&self, tracker: &H256) -> Vec<(H256, Option<String>)>;
+    fn error_hints_by_tracker(&self, tracker: &Tracker) -> Vec<(H256, Option<String>)>;
 
     /// Get error hint
     fn error_hint(&self, hash: &H256) -> Option<String>;
@@ -93,7 +94,7 @@ impl InvoiceProvider for InvoiceDB {
         self.db.exists_with_cache(db::COL_ERROR_HINT, &self.hash_cache, hash)
     }
 
-    fn error_hints_by_tracker(&self, tracker: &H256) -> Vec<(H256, Option<String>)> {
+    fn error_hints_by_tracker(&self, tracker: &Tracker) -> Vec<(H256, Option<String>)> {
         self.db
             .read_with_cache(db::COL_ERROR_HINT, &mut *self.tracker_cache.write(), tracker)
             .map(|hashes| (*hashes).clone())
@@ -175,7 +176,7 @@ impl Key<Option<String>> for H256 {
     }
 }
 
-impl Key<TrackerInvoices> for H256 {
+impl Key<TrackerInvoices> for Tracker {
     type Target = H264;
 
     fn key(&self) -> H264 {

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};
+use ctypes::{BlockHash, BlockNumber, CommonParams, ShardId, Tracker};
 use cvm::{decode, execute, ChainTimeInfo, ScriptResult, VMConfig};
 use hashdb::AsHashDB;
 use journaldb;
@@ -239,7 +239,7 @@ impl Client {
         }
     }
 
-    fn transaction_addresses(&self, tracker: &H256) -> Option<TransactionAddress> {
+    fn transaction_addresses(&self, tracker: &Tracker) -> Option<TransactionAddress> {
         self.block_chain().transaction_address_by_tracker(tracker)
     }
 
@@ -366,7 +366,13 @@ impl AssetClient for Client {
         }
     }
 
-    fn get_asset(&self, tracker: H256, index: usize, shard_id: ShardId, id: BlockId) -> TrieResult<Option<OwnedAsset>> {
+    fn get_asset(
+        &self,
+        tracker: Tracker,
+        index: usize,
+        shard_id: ShardId,
+        id: BlockId,
+    ) -> TrieResult<Option<OwnedAsset>> {
         if let Some(state) = Client::state_at(&self, id) {
             Ok(state.asset(shard_id, tracker, index)?)
         } else {
@@ -379,7 +385,7 @@ impl AssetClient for Client {
     /// It returns None if such an asset never existed in the shard at the given block.
     fn is_asset_spent(
         &self,
-        tracker: H256,
+        tracker: Tracker,
         index: usize,
         shard_id: ShardId,
         block_id: BlockId,
@@ -629,7 +635,7 @@ impl BlockChainTrait for Client {
         self.transaction_address(id).map(|addr| addr.block_hash)
     }
 
-    fn transaction_header(&self, tracker: &H256) -> Option<::encoded::Header> {
+    fn transaction_header(&self, tracker: &Tracker) -> Option<::encoded::Header> {
         self.transaction_addresses(tracker).map(|addr| addr.block_hash).and_then(|hash| self.block_header(&hash.into()))
     }
 }
@@ -796,13 +802,13 @@ impl BlockChainClient for Client {
         chain.error_hint(hash)
     }
 
-    fn transaction_by_tracker(&self, tracker: &H256) -> Option<LocalizedTransaction> {
+    fn transaction_by_tracker(&self, tracker: &Tracker) -> Option<LocalizedTransaction> {
         let chain = self.block_chain();
         let address = self.transaction_addresses(tracker);
         address.and_then(|address| chain.transaction(&address))
     }
 
-    fn error_hints_by_tracker(&self, tracker: &H256) -> Vec<(H256, Option<String>)> {
+    fn error_hints_by_tracker(&self, tracker: &Tracker) -> Vec<(H256, Option<String>)> {
         let chain = self.block_chain();
         chain.error_hints_by_tracker(tracker)
     }
@@ -919,11 +925,11 @@ impl MiningBlockChainClient for Client {
 }
 
 impl ChainTimeInfo for Client {
-    fn transaction_block_age(&self, tracker: &H256, parent_block_number: BlockNumber) -> Option<u64> {
+    fn transaction_block_age(&self, tracker: &Tracker, parent_block_number: BlockNumber) -> Option<u64> {
         self.transaction_block_number(tracker).map(|block_number| parent_block_number - block_number)
     }
 
-    fn transaction_time_age(&self, tracker: &H256, parent_timestamp: u64) -> Option<u64> {
+    fn transaction_time_age(&self, tracker: &Tracker, parent_timestamp: u64) -> Option<u64> {
         self.transaction_block_timestamp(tracker).map(|block_timestamp| parent_timestamp - block_timestamp)
     }
 }

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};
+use ctypes::{BlockHash, BlockNumber, CommonParams, ShardId, Tracker};
 use cvm::ChainTimeInfo;
 use kvdb::KeyValueDB;
 use primitives::{Bytes, H160, H256, U256};
@@ -75,13 +75,13 @@ pub trait BlockChainTrait {
     /// Get the hash of block that contains the transaction, if any.
     fn transaction_block(&self, id: &TransactionId) -> Option<BlockHash>;
 
-    fn transaction_header(&self, tracker: &H256) -> Option<::encoded::Header>;
+    fn transaction_header(&self, tracker: &Tracker) -> Option<::encoded::Header>;
 
-    fn transaction_block_number(&self, tracker: &H256) -> Option<BlockNumber> {
+    fn transaction_block_number(&self, tracker: &Tracker) -> Option<BlockNumber> {
         self.transaction_header(tracker).map(|header| header.number())
     }
 
-    fn transaction_block_timestamp(&self, tracker: &H256) -> Option<u64> {
+    fn transaction_block_timestamp(&self, tracker: &Tracker) -> Option<u64> {
         self.transaction_header(tracker).map(|header| header.timestamp())
     }
 }
@@ -253,9 +253,9 @@ pub trait BlockChainClient: Sync + Send + AccountData + BlockChainTrait + Import
     fn error_hint(&self, hash: &H256) -> Option<String>;
 
     /// Get the transaction with given tracker.
-    fn transaction_by_tracker(&self, tracker: &H256) -> Option<LocalizedTransaction>;
+    fn transaction_by_tracker(&self, tracker: &Tracker) -> Option<LocalizedTransaction>;
 
-    fn error_hints_by_tracker(&self, tracker: &H256) -> Vec<(H256, Option<String>)>;
+    fn error_hints_by_tracker(&self, tracker: &Tracker) -> Vec<(H256, Option<String>)>;
 }
 
 /// Result of import block operation.
@@ -300,11 +300,17 @@ pub trait DatabaseClient {
 pub trait AssetClient {
     fn get_asset_scheme(&self, asset_type: H160, shard_id: ShardId, id: BlockId) -> TrieResult<Option<AssetScheme>>;
 
-    fn get_asset(&self, tracker: H256, index: usize, shard_id: ShardId, id: BlockId) -> TrieResult<Option<OwnedAsset>>;
+    fn get_asset(
+        &self,
+        tracker: Tracker,
+        index: usize,
+        shard_id: ShardId,
+        id: BlockId,
+    ) -> TrieResult<Option<OwnedAsset>>;
 
     fn is_asset_spent(
         &self,
-        tracker: H256,
+        tracker: Tracker,
         index: usize,
         shard_id: ShardId,
         block_id: BlockId,