Remove unused insert_epoch_transition

Inserted `EpochTransition` is not read anymore and inserting it does not
change state. So removing it doesn't introduce breaking change unless
reusing the key index.

Author: foriequal0

core/src/blockchain/blockchain.rs

@@ -24,14 +24,13 @@ use rlp::RlpStream;
 
 use super::block_info::BestBlockChanged;
 use super::body_db::{BodyDB, BodyProvider};
-use super::extras::{BlockDetails, EpochTransitions, TransactionAddress};
+use super::extras::{BlockDetails, TransactionAddress};
 use super::headerchain::{HeaderChain, HeaderProvider};
 use super::invoice_db::{InvoiceDB, InvoiceProvider};
 use super::route::{tree_route, ImportRoute};
 use crate::blockchain_info::BlockChainInfo;
-use crate::consensus::epoch::Transition as EpochTransition;
 use crate::consensus::CodeChainEngine;
-use crate::db::{self, Readable, Writable};
+use crate::db;
 use crate::encoded;
 use crate::invoice::Invoice;
 use crate::transaction::LocalizedTransaction;
@@ -53,8 +52,6 @@ pub struct BlockChain {
     body_db: BodyDB,
     invoice_db: InvoiceDB,
 
-    db: Arc<KeyValueDB>,
-
     pending_best_block_hash: RwLock<Option<H256>>,
     pending_best_proposal_block_hash: RwLock<Option<H256>>,
 }
@@ -96,8 +93,6 @@ impl BlockChain {
             body_db: BodyDB::new(&genesis_block, db.clone()),
             invoice_db: InvoiceDB::new(db.clone()),
 
-            db,
-
             pending_best_block_hash: RwLock::new(None),
             pending_best_proposal_block_hash: RwLock::new(None),
         }
@@ -341,26 +336,6 @@ impl BlockChain {
     pub fn best_proposal_header(&self) -> encoded::Header {
         self.headerchain.best_proposal_header()
     }
-
-    /// Insert an epoch transition. Provide an epoch number being transitioned to
-    /// and epoch transition object.
-    ///
-    /// The block the transition occurred at should have already been inserted into the chain.
-    pub fn insert_epoch_transition(&self, batch: &mut DBTransaction, epoch_num: u64, transition: EpochTransition) {
-        let mut transitions = match self.db.read(db::COL_EXTRA, &epoch_num) {
-            Some(existing) => existing,
-            None => EpochTransitions {
-                number: epoch_num,
-                candidates: Vec::with_capacity(1),
-            },
-        };
-
-        // ensure we don't write any duplicates.
-        if transitions.candidates.iter().find(|c| c.block_hash == transition.block_hash).is_none() {
-            transitions.candidates.push(transition);
-            batch.write(db::COL_EXTRA, &epoch_num, &transitions);
-        }
-    }
 }
 
 /// Interface for querying blocks by hash and by number.

core/src/blockchain/extras.rs

@@ -14,14 +14,11 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-use std::io::Write;
-use std::ops::{self, Add, AddAssign, Deref, Sub, SubAssign};
+use std::ops::{Add, AddAssign, Deref, Sub, SubAssign};
 
 use ctypes::BlockNumber;
-use kvdb::PREFIX_LEN as DB_PREFIX_LEN;
 use primitives::{H256, H264, U256};
 
-use crate::consensus::epoch::Transition as EpochTransition;
 use crate::db::Key;
 use crate::types::TransactionId;
 
@@ -36,8 +33,7 @@ enum ExtrasIndex {
     ParcelAddress = 2,
     /// Transaction address index
     TransactionAddress = 3,
-    /// Epoch transition data index.
-    EpochTransitions = 4,
+    // (Reserved) = 4,
     // (Reserved) = 5,
 }
 
@@ -97,38 +93,6 @@ impl Key<TransactionAddresses> for H256 {
     }
 }
 
-/// length of epoch keys.
-const EPOCH_KEY_LEN: usize = DB_PREFIX_LEN + 16;
-
-/// epoch key prefix.
-/// used to iterate over all epoch transitions in order from genesis.
-pub const EPOCH_KEY_PREFIX: &[u8; DB_PREFIX_LEN] =
-    &[ExtrasIndex::EpochTransitions as u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-
-pub struct EpochTransitionsKey([u8; EPOCH_KEY_LEN]);
-
-impl ops::Deref for EpochTransitionsKey {
-    type Target = [u8];
-
-    fn deref(&self) -> &[u8] {
-        &self.0[..]
-    }
-}
-
-impl Key<EpochTransitions> for u64 {
-    type Target = EpochTransitionsKey;
-
-    fn key(&self) -> Self::Target {
-        let mut arr = [0u8; EPOCH_KEY_LEN];
-        arr[..DB_PREFIX_LEN].copy_from_slice(&EPOCH_KEY_PREFIX[..]);
-
-        write!(&mut arr[DB_PREFIX_LEN..], "{:016x}", self)
-            .expect("format arg is valid; no more than 16 chars will be written; qed");
-
-        EpochTransitionsKey(arr)
-    }
-}
-
 /// Familial details concerning a block
 #[derive(Debug, Clone, RlpEncodable, RlpDecodable)]
 pub struct BlockDetails {
@@ -161,13 +125,6 @@ pub struct TransactionAddresses {
     addresses: Vec<TransactionAddress>,
 }
 
-/// Candidate transitions to an epoch with specific number.
-#[derive(Clone, RlpEncodable, RlpDecodable)]
-pub struct EpochTransitions {
-    pub number: u64,
-    pub candidates: Vec<EpochTransition>,
-}
-
 impl TransactionAddresses {
     pub fn new(address: TransactionAddress) -> Self {
         Self {

core/src/client/importer.rs

@@ -27,8 +27,7 @@ use rlp::Encodable;
 
 use super::{BlockChainTrait, Client, ClientConfig};
 use crate::block::{enact, IsBlock, LockedBlock};
-use crate::blockchain::{BlockChain, BodyProvider, HeaderProvider, ImportRoute};
-use crate::consensus::epoch::Transition as EpochTransition;
+use crate::blockchain::{BodyProvider, HeaderProvider, ImportRoute};
 use crate::consensus::CodeChainEngine;
 use crate::encoded;
 use crate::error::Error;
@@ -207,8 +206,6 @@ impl Importer {
         client.db().write_buffered(batch);
         chain.commit();
 
-        self.check_epoch_end(block.header(), &chain, client);
-
         if hash == chain.best_block_hash() {
             let mut state_db = client.state_db().write();
             let state = block.state();
@@ -218,27 +215,6 @@ impl Importer {
         route
     }
 
-    // check for ending of epoch and write transition if it occurs.
-    fn check_epoch_end(&self, header: &Header, chain: &BlockChain, client: &Client) {
-        let is_epoch_end = self.engine.is_epoch_end(header, &(|hash| chain.block_header(&hash)));
-
-        if let Some(proof) = is_epoch_end {
-            cdebug!(CLIENT, "Epoch transition at block {}", header.hash());
-
-            let mut batch = DBTransaction::new();
-            chain.insert_epoch_transition(&mut batch, header.number(), EpochTransition {
-                block_hash: header.hash(),
-                block_number: header.number(),
-                proof,
-            });
-
-            // always write the batch directly since epoch transition proofs are
-            // fetched from a DB iterator and DB iterators are only available on
-            // flushed data.
-            client.db().write(batch).expect("DB flush failed");
-        }
-    }
-
     fn check_and_close_block(&self, block: &PreverifiedBlock, client: &Client) -> Result<LockedBlock, ()> {
         let engine = &*self.engine;
         let header = &block.header;
@@ -424,15 +400,10 @@ impl Importer {
         let chain = client.block_chain();
 
         let mut batch = DBTransaction::new();
-        // FIXME: Check if this line is still necessary.
-        // self.check_epoch_end_signal(header, &chain, &mut batch);
         let route = chain.insert_header(&mut batch, &HeaderView::new(&header.rlp_bytes()), self.engine.borrow());
         client.db().write_buffered(batch);
         chain.commit();
 
-        // FIXME: Check if this line is still necessary.
-        // self.check_epoch_end(&header, &chain, client);
-
         route
     }
 }

core/src/consensus/epoch.rs

@@ -16,7 +16,6 @@
 
 mod blake_pow;
 mod cuckoo;
-pub mod epoch;
 mod null_engine;
 mod signer;
 mod simple_poa;
@@ -200,17 +199,6 @@ pub trait ConsensusEngine: Sync + Send {
         Ok(())
     }
 
-    /// Whether a block is the end of an epoch.
-    ///
-    /// This either means that an immediate transition occurs or a block signalling transition
-    /// has reached finality. The `Headers` given are not guaranteed to return any blocks
-    /// from any epoch other than the current.
-    ///
-    /// Return optional transition proof.
-    fn is_epoch_end(&self, _chain_head: &Header, _chain: &Headers<Header>) -> Option<Vec<u8>> {
-        None
-    }
-
     /// Populate a header's fields based on its parent's header.
     /// Usually implements the chain scoring rule based on weight.
     fn populate_from_parent(&self, _header: &mut Header, _parent: &Header) {}
@@ -283,9 +271,6 @@ pub trait ConsensusEngine: Sync + Send {
     }
 }
 
-/// Type alias for a function we can get headers by hash through.
-pub type Headers<'a, H> = Fn(H256) -> Option<H> + 'a;
-
 /// Voting errors.
 #[derive(Debug)]
 pub enum EngineError {

core/src/consensus/mod.rs

@@ -117,15 +117,6 @@ impl ConsensusEngine for SimplePoA {
         verify_external(header, &*self.validators)
     }
 
-    fn is_epoch_end(&self, chain_head: &Header, _chain: &super::Headers<Header>) -> Option<Vec<u8>> {
-        let first = chain_head.number() == 0;
-        if first {
-            Some(Vec::new())
-        } else {
-            None
-        }
-    }
-
     fn on_close_block(&self, block: &mut ExecutedBlock) -> Result<(), Error> {
         let author = *block.header().author();
         let total_reward = self.block_reward(block.header().number())

core/src/consensus/simple_poa/mod.rs

@@ -22,7 +22,6 @@ use ckey::Address;
 use cnetwork::NetworkService;
 use crossbeam_channel as crossbeam;
 use cstate::ActionHandler;
-use ctypes::BlockNumber;
 use primitives::H256;
 
 use super::super::stake;
@@ -114,16 +113,6 @@ impl ConsensusEngine for Tendermint {
         receiver.recv().unwrap()
     }
 
-    fn is_epoch_end(&self, chain_head: &Header, _chain: &super::super::Headers<Header>) -> Option<Vec<u8>> {
-        let first = chain_head.number() == 0;
-        if first {
-            let change = combine_proofs(chain_head.number(), &[], &[]);
-            return Some(change)
-        }
-
-        None
-    }
-
     fn populate_from_parent(&self, header: &mut Header, _parent: &Header) {
         let (result, receiver) = crossbeam::bounded(1);
         self.inner
@@ -249,9 +238,3 @@ impl ConsensusEngine for Tendermint {
         &self.action_handlers
     }
 }
-
-fn combine_proofs(signal_number: BlockNumber, set_proof: &[u8], finality_proof: &[u8]) -> Vec<u8> {
-    let mut stream = ::rlp::RlpStream::new_list(3);
-    stream.append(&signal_number).append(&set_proof).append(&finality_proof);
-    stream.out()
-}