Remove retracted from ImportRoute

ImportRoute no longer allows retracted blocks or headers

Author: HoOngEe

core/src/blockchain/route.rs

@@ -110,11 +110,9 @@ pub fn tree_route(db: &dyn HeaderProvider, from: BlockHash, to: BlockHash) -> Op
 /// Import route for newly inserted block.
 #[derive(Debug, PartialEq)]
 pub struct ImportRoute {
-    /// Blocks that were invalidated by new block.
-    pub retracted: Vec<BlockHash>,
     /// Blocks that were validated by new block.
     pub enacted: Vec<BlockHash>,
-    /// Blocks which are neither retracted nor enacted.
+    /// Blocks which are not enacted.
     pub omitted: Vec<BlockHash>,
 }
 
@@ -132,13 +130,11 @@ impl ImportRoute {
                 let mut enacted = Vec::new();
                 enacted.push(best_block_changed.new_best_hash().unwrap());
                 ImportRoute {
-                    retracted: vec![],
                     enacted,
                     omitted,
                 }
             }
             BestBlockChanged::None => ImportRoute {
-                retracted: vec![],
                 enacted: vec![],
                 omitted,
             },
@@ -157,13 +153,11 @@ impl ImportRoute {
             } => {
                 let enacted = vec![best_header_changed.new_best_hash().unwrap()];
                 ImportRoute {
-                    retracted: vec![],
                     enacted,
                     omitted,
                 }
             }
             BestHeaderChanged::None => ImportRoute {
-                retracted: vec![],
                 enacted: vec![],
                 omitted,
             },
@@ -172,13 +166,12 @@ impl ImportRoute {
 
     pub fn none() -> Self {
         ImportRoute {
-            retracted: vec![],
             enacted: vec![],
             omitted: vec![],
         }
     }
 
     pub fn is_none(&self) -> bool {
-        self.retracted.is_empty() && self.enacted.is_empty() && self.omitted.is_empty()
+        self.enacted.is_empty() && self.omitted.is_empty()
     }
 }

core/src/client/chain_notify.rs

@@ -1,4 +1,4 @@
-// Copyright 2018-2019 Kodebox, Inc.
+// Copyright 2018-2020 Kodebox, Inc.
 // This file is part of CodeChain.
 //
 // This program is free software: you can redistribute it and/or modify
@@ -25,7 +25,6 @@ pub trait ChainNotify: Send + Sync {
         _imported: Vec<BlockHash>,
         _invalid: Vec<BlockHash>,
         _enacted: Vec<BlockHash>,
-        _retracted: Vec<BlockHash>,
         _sealed: Vec<BlockHash>,
         _new_best_proposal: Option<BlockHash>,
     ) {
@@ -38,7 +37,6 @@ pub trait ChainNotify: Send + Sync {
         _imported: Vec<BlockHash>,
         _invalid: Vec<BlockHash>,
         _enacted: Vec<BlockHash>,
-        _retracted: Vec<BlockHash>,
         _sealed: Vec<BlockHash>,
     ) {
         // does nothing by default

core/src/client/client.rs

@@ -150,26 +150,16 @@ impl Client {
         imported: &[BlockHash],
         invalid: &[BlockHash],
         enacted: &[BlockHash],
-        retracted: &[BlockHash],
         sealed: &[BlockHash],
     ) {
-        self.notify(|notify| {
-            notify.new_blocks(
-                imported.to_vec(),
-                invalid.to_vec(),
-                enacted.to_vec(),
-                retracted.to_vec(),
-                sealed.to_vec(),
-            )
-        });
+        self.notify(|notify| notify.new_blocks(imported.to_vec(), invalid.to_vec(), enacted.to_vec(), sealed.to_vec()));
     }
 
     pub fn new_headers(
         &self,
         imported: &[BlockHash],
         invalid: &[BlockHash],
         enacted: &[BlockHash],
-        retracted: &[BlockHash],
         sealed: &[BlockHash],
         new_best_proposal: Option<BlockHash>,
     ) {
@@ -178,7 +168,6 @@ impl Client {
                 imported.to_vec(),
                 invalid.to_vec(),
                 enacted.to_vec(),
-                retracted.to_vec(),
                 sealed.to_vec(),
                 new_best_proposal,
             );
@@ -273,9 +262,9 @@ impl Client {
             return
         }
 
-        let (enacted, retracted) = self.importer.calculate_enacted_retracted(&[route]);
-        self.importer.miner.chain_new_blocks(self, &[], &[], &enacted, &retracted);
-        self.new_blocks(&[], &[], &enacted, &retracted, &[]);
+        let enacted = self.importer.extract_enacted(vec![route]);
+        self.importer.miner.chain_new_blocks(self, &[], &[], &enacted);
+        self.new_blocks(&[], &[], &enacted, &[]);
     }
 
     fn block_number_ref(&self, id: &BlockId) -> Option<BlockNumber> {
@@ -664,9 +653,9 @@ impl ImportBlock for Client {
             cinfo!(CLIENT, "Imported sealed block #{} ({})", number, h);
             route
         };
-        let (enacted, retracted) = self.importer.calculate_enacted_retracted(&[route]);
-        self.importer.miner.chain_new_blocks(self, &[h], &[], &enacted, &retracted);
-        self.new_blocks(&[h], &[], &enacted, &retracted, &[h]);
+        let enacted = self.importer.extract_enacted(vec![route]);
+        self.importer.miner.chain_new_blocks(self, &[h], &[], &enacted);
+        self.new_blocks(&[h], &[], &enacted, &[h]);
         self.db().flush().expect("DB flush failed.");
         Ok(h)
     }

core/src/client/importer.rs

@@ -1,4 +1,4 @@
-// Copyright 2018-2019 Kodebox, Inc.
+// Copyright 2018-2020 Kodebox, Inc.
 // This file is part of CodeChain.
 //
 // This program is free software: you can redistribute it and/or modify
@@ -33,7 +33,8 @@ use kvdb::DBTransaction;
 use parking_lot::{Mutex, MutexGuard};
 use rlp::Encodable;
 use std::borrow::Borrow;
-use std::collections::{HashMap, HashSet};
+use std::collections::HashSet;
+use std::iter::FromIterator;
 use std::sync::Arc;
 
 pub struct Importer {
@@ -134,40 +135,22 @@ impl Importer {
                 if !is_empty {
                     ctrace!(CLIENT, "Call new_blocks even though block verification queue is not empty");
                 }
-                let (enacted, retracted) = self.calculate_enacted_retracted(&import_results);
-                self.miner.chain_new_blocks(client, &imported_blocks, &invalid_blocks, &enacted, &retracted);
-                client.new_blocks(&imported_blocks, &invalid_blocks, &enacted, &retracted, &[]);
+                let enacted = self.extract_enacted(import_results);
+                self.miner.chain_new_blocks(client, &imported_blocks, &invalid_blocks, &enacted);
+                client.new_blocks(&imported_blocks, &invalid_blocks, &enacted, &[]);
             }
         }
 
         client.db().flush().expect("DB flush failed.");
         imported
     }
 
-    pub fn calculate_enacted_retracted(&self, import_results: &[ImportRoute]) -> (Vec<BlockHash>, Vec<BlockHash>) {
-        fn map_to_vec(map: Vec<(BlockHash, bool)>) -> Vec<BlockHash> {
-            map.into_iter().map(|(k, _v)| k).collect()
-        }
-
-        // In ImportRoute we get all the blocks that have been enacted and retracted by single insert.
-        // Because we are doing multiple inserts some of the blocks that were enacted in import `k`
-        // could be retracted in import `k+1`. This is why to understand if after all inserts
-        // the block is enacted or retracted we iterate over all routes and at the end final state
-        // will be in the hashmap
-        let map = import_results.iter().fold(HashMap::new(), |mut map, route| {
-            for hash in &route.enacted {
-                map.insert(*hash, true);
-            }
-            for hash in &route.retracted {
-                map.insert(*hash, false);
-            }
-            map
+    pub fn extract_enacted(&self, import_results: Vec<ImportRoute>) -> Vec<BlockHash> {
+        let set = import_results.into_iter().fold(HashSet::new(), |mut set, route| {
+            set.extend(route.enacted);
+            set
         });
-
-        // Split to enacted retracted (using hashmap value)
-        let (enacted, retracted) = map.into_iter().partition(|&(_k, v)| v);
-        // And convert tuples to keys
-        (map_to_vec(enacted), map_to_vec(retracted))
+        Vec::from_iter(set)
     }
 
     // NOTE: the header of the block passed here is not necessarily sealed, as
@@ -336,7 +319,7 @@ impl Importer {
         }
 
         self.header_queue.mark_as_bad(&bad.drain().collect::<Vec<_>>());
-        let (enacted, retracted) = self.calculate_enacted_retracted(&routes);
+        let enacted = self.extract_enacted(routes);
 
         let new_best_proposal_header_hash = client.block_chain().best_proposal_header().hash();
         let best_proposal_header_changed = if prev_best_proposal_header_hash != new_best_proposal_header_hash {
@@ -349,7 +332,6 @@ impl Importer {
             &imported,
             &bad.iter().cloned().collect::<Vec<_>>(),
             &enacted,
-            &retracted,
             &[],
             best_proposal_header_changed,
         );
@@ -370,7 +352,7 @@ impl Importer {
             client.db().write_buffered(batch);
             chain.commit();
         }
-        client.new_headers(&[hash], &[], &[], &[], &[], None);
+        client.new_headers(&[hash], &[], &[], &[], None);
 
         client.db().flush().expect("DB flush failed.");
     }
@@ -388,8 +370,8 @@ impl Importer {
             client.db().write_buffered(batch);
             chain.commit();
         }
-        self.miner.chain_new_blocks(client, &[hash], &[], &[], &[]);
-        client.new_blocks(&[hash], &[], &[], &[], &[]);
+        self.miner.chain_new_blocks(client, &[hash], &[], &[]);
+        client.new_blocks(&[hash], &[], &[], &[]);
 
         client.db().flush().expect("DB flush failed.");
     }

core/src/consensus/tendermint/chain_notify.rs

@@ -38,7 +38,6 @@ impl ChainNotify for TendermintChainNotify {
         imported: Vec<BlockHash>,
         _invalid: Vec<BlockHash>,
         enacted: Vec<BlockHash>,
-        _retracted: Vec<BlockHash>,
         _sealed: Vec<BlockHash>,
     ) {
         self.inner

core/src/miner/miner.rs

@@ -598,30 +598,11 @@ impl MinerService for Miner {
         self.mem_pool.write().set_limit(limit)
     }
 
-    fn chain_new_blocks<C>(
-        &self,
-        chain: &C,
-        _imported: &[BlockHash],
-        _invalid: &[BlockHash],
-        _enacted: &[BlockHash],
-        retracted: &[BlockHash],
-    ) where
+    fn chain_new_blocks<C>(&self, chain: &C, _imported: &[BlockHash], _invalid: &[BlockHash], _enacted: &[BlockHash])
+    where
         C: AccountData + BlockChainTrait + BlockProducer + EngineInfo + ImportBlock, {
         ctrace!(MINER, "chain_new_blocks");
 
-        // Then import all transactions...
-        {
-            let mut mem_pool = self.mem_pool.write();
-            for hash in retracted {
-                let block = chain.block(&(*hash).into()).expect(
-                    "Client is sending message after commit to db and inserting to chain; the block is available; qed",
-                );
-                let transactions = block.transactions();
-                let _ = self.add_transactions_to_pool(chain, transactions, TxOrigin::RetractedBlock, &mut mem_pool);
-            }
-        }
-
-        // ...and at the end remove the old ones
         {
             let fetch_account = |p: &Public| {
                 let address = public_to_address(p);

core/src/miner/mod.rs

@@ -1,4 +1,4 @@
-// Copyright 2018-2019 Kodebox, Inc.
+// Copyright 2018-2020 Kodebox, Inc.
 // This file is part of CodeChain.
 //
 // This program is free software: you can redistribute it and/or modify
@@ -63,14 +63,8 @@ pub trait MinerService: Send + Sync {
     fn set_transactions_limit(&self, limit: usize);
 
     /// Called when blocks are imported to chain, updates transactions queue.
-    fn chain_new_blocks<C>(
-        &self,
-        chain: &C,
-        imported: &[BlockHash],
-        invalid: &[BlockHash],
-        enacted: &[BlockHash],
-        retracted: &[BlockHash],
-    ) where
+    fn chain_new_blocks<C>(&self, chain: &C, imported: &[BlockHash], invalid: &[BlockHash], enacted: &[BlockHash])
+    where
         C: AccountData + BlockChainTrait + BlockProducer + EngineInfo + ImportBlock;
 
     /// Get the type of consensus engine.

sync/src/block/extension.rs

@@ -666,9 +666,8 @@ impl NetworkExtension<Event> for Extension {
             Event::NewHeaders {
                 imported,
                 enacted,
-                retracted,
             } => {
-                self.new_headers(imported, enacted, retracted);
+                self.new_headers(imported, enacted);
             }
             Event::NewBlocks {
                 imported,
@@ -685,7 +684,6 @@ pub enum Event {
     NewHeaders {
         imported: Vec<BlockHash>,
         enacted: Vec<BlockHash>,
-        retracted: Vec<BlockHash>,
     },
     NewBlocks {
         imported: Vec<BlockHash>,
@@ -694,7 +692,7 @@ pub enum Event {
 }
 
 impl Extension {
-    fn new_headers(&mut self, imported: Vec<BlockHash>, enacted: Vec<BlockHash>, retracted: Vec<BlockHash>) {
+    fn new_headers(&mut self, imported: Vec<BlockHash>, enacted: Vec<BlockHash>) {
         if let State::Full = self.state {
             for peer in self.header_downloaders.values_mut() {
                 peer.mark_as_imported(imported.clone());
@@ -715,7 +713,6 @@ impl Extension {
             for header in headers {
                 self.body_downloader.add_target(&header.decode());
             }
-            self.body_downloader.remove_target(&retracted);
         }
     }
 
@@ -1184,15 +1181,13 @@ impl ChainNotify for BlockSyncSender {
         imported: Vec<BlockHash>,
         _invalid: Vec<BlockHash>,
         enacted: Vec<BlockHash>,
-        retracted: Vec<BlockHash>,
         _sealed: Vec<BlockHash>,
         _new_best_proposal: Option<BlockHash>,
     ) {
         self.0
             .send(Event::NewHeaders {
                 imported,
                 enacted,
-                retracted,
             })
             .unwrap();
     }
@@ -1202,7 +1197,6 @@ impl ChainNotify for BlockSyncSender {
         imported: Vec<BlockHash>,
         invalid: Vec<BlockHash>,
         _enacted: Vec<BlockHash>,
-        _retracted: Vec<BlockHash>,
         _sealed: Vec<BlockHash>,
     ) {
         self.0