Revert "value ranges in consensus cache"

This reverts commit 9062f94.

core/client/db/src/cache/list_cache.rs

@@ -130,10 +130,7 @@ impl<Block: BlockT, T: CacheItemT, S: Storage<Block, T>> ListCache<Block, T, S>
 	}
 
 	/// Get value valid at block.
-	pub fn value_at_block(
-		&self,
-		at: &ComplexBlockId<Block>,
-	) -> ClientResult<Option<(ComplexBlockId<Block>, Option<ComplexBlockId<Block>>, T)>> {
+	pub fn value_at_block(&self, at: &ComplexBlockId<Block>) -> ClientResult<Option<T>> {
 		let head = if at.number <= self.best_finalized_block.number {
 			// if the block is older than the best known finalized block
 			// => we're should search for the finalized value
@@ -167,7 +164,7 @@ impl<Block: BlockT, T: CacheItemT, S: Storage<Block, T>> ListCache<Block, T, S>
 
 		match head {
 			Some(head) => head.search_best_before(&self.storage, at.number)
-				.map(|e| e.map(|e| (e.0.valid_from, e.1, e.0.value))),
+				.map(|e| e.map(|e| e.0.value)),
 			None => Ok(None),
 		}
 	}
@@ -680,7 +677,7 @@ pub mod tests {
 				.with_entry(test_id(100), StorageEntry { prev_valid_from: Some(test_id(30)), value: 100 })
 				.with_entry(test_id(30), StorageEntry { prev_valid_from: None, value: 30 }),
 			1024, test_id(100)
-		).value_at_block(&test_id(50)).unwrap(), Some((test_id(30), Some(test_id(100)), 30)));
+		).value_at_block(&test_id(50)).unwrap(), Some(30));
 		// when block is the best finalized block AND value is some
 		// ---> [100]
 		assert_eq!(ListCache::new(
@@ -690,7 +687,7 @@ pub mod tests {
 				.with_entry(test_id(100), StorageEntry { prev_valid_from: Some(test_id(30)), value: 100 })
 				.with_entry(test_id(30), StorageEntry { prev_valid_from: None, value: 30 }),
 			1024, test_id(100)
-		).value_at_block(&test_id(100)).unwrap(), Some((test_id(100), None, 100)));
+		).value_at_block(&test_id(100)).unwrap(), Some(100));
 		// when block is parallel to the best finalized block
 		// ---- 100
 		// ---> [100]
@@ -711,7 +708,7 @@ pub mod tests {
 				.with_id(50, H256::from_low_u64_be(50))
 				.with_entry(test_id(100), StorageEntry { prev_valid_from: Some(test_id(30)), value: 100 }),
 			1024, test_id(100)
-		).value_at_block(&test_id(200)).unwrap(), Some((test_id(100), None, 100)));
+		).value_at_block(&test_id(200)).unwrap(), Some(100));
 
 		// when block is later than last finalized block AND there are no matching forks
 		// AND block is connected to finalized block AND finalized value is Some
@@ -727,7 +724,7 @@ pub mod tests {
 				.with_header(test_header(4))
 				.with_header(fork_header(0, 2, 3)),
 			1024, test_id(2)
-		).value_at_block(&fork_id(0, 2, 3)).unwrap(), Some((correct_id(2), None, 2)));
+		).value_at_block(&fork_id(0, 2, 3)).unwrap(), Some(2));
 		// when block is later than last finalized block AND there are no matching forks
 		// AND block is not connected to finalized block
 		//    ---   2  --- 3
@@ -757,7 +754,7 @@ pub mod tests {
 				.with_header(test_header(4))
 				.with_header(test_header(5)),
 			1024, test_id(2)
-		).value_at_block(&correct_id(5)).unwrap(), Some((correct_id(4), None, 4)));
+		).value_at_block(&correct_id(5)).unwrap(), Some(4));
 		// when block is later than last finalized block AND it does not fits unfinalized fork
 		// AND it is connected to the finalized block AND finalized value is Some
 		// ---> [2] ----------> [4]
@@ -772,7 +769,7 @@ pub mod tests {
 				.with_header(test_header(4))
 				.with_header(fork_header(0, 2, 3)),
 			1024, test_id(2)
-		).value_at_block(&fork_id(0, 2, 3)).unwrap(), Some((correct_id(2), None, 2)));
+		).value_at_block(&fork_id(0, 2, 3)).unwrap(), Some(2));
 	}
 
 	#[test]

core/client/db/src/cache/mod.rs

@@ -294,11 +294,7 @@ impl<Block: BlockT> BlockchainCache<Block> for DbCacheSync<Block> {
 		Ok(())
 	}
 
-	fn get_at(
-		&self,
-		key: &CacheKeyId,
-		at: &BlockId<Block>,
-	) -> Option<((NumberFor<Block>, Block::Hash), Option<(NumberFor<Block>, Block::Hash)>, Vec<u8>)> {
+	fn get_at(&self, key: &CacheKeyId, at: &BlockId<Block>) -> Option<Vec<u8>> {
 		let cache = self.0.read();
 		let storage = cache.cache_at.get(key)?.storage();
 		let db = storage.db();
@@ -322,15 +318,7 @@ impl<Block: BlockT> BlockchainCache<Block> for DbCacheSync<Block> {
 			},
 		};
 
-		cache.cache_at.get(key)?
-			.value_at_block(&at)
-			.map(|block_and_value| block_and_value.map(|(begin_block, end_block, value)|
-				(
-					(begin_block.number, begin_block.hash),
-					end_block.map(|end_block| (end_block.number, end_block.hash)),
-					value,
-				)))
-			.ok()?
+		cache.cache_at.get(key)?.value_at_block(&at).ok()?
 	}
 }
 

core/client/db/src/light.rs

@@ -600,10 +600,10 @@ pub(crate) mod tests {
 		header
 	}
 
-	pub fn insert_block<F: FnMut() -> Header>(
+	pub fn insert_block<F: Fn() -> Header>(
 		db: &LightStorage<Block>,
 		cache: HashMap<well_known_cache_keys::Id, Vec<u8>>,
-		mut header: F,
+		header: F,
 	) -> Hash {
 		let header = header();
 		let hash = header.hash();
@@ -887,8 +887,7 @@ pub(crate) mod tests {
 		}
 
 		fn get_authorities(cache: &dyn BlockchainCache<Block>, at: BlockId<Block>) -> Option<Vec<AuthorityId>> {
-			cache.get_at(&well_known_cache_keys::AUTHORITIES, &at)
-				.and_then(|(_, _, val)| Decode::decode(&mut &val[..]))
+			cache.get_at(&well_known_cache_keys::AUTHORITIES, &at).and_then(|val| Decode::decode(&mut &val[..]))
 		}
 
 		let auth1 = || AuthorityId::from_raw([1u8; 32]);
@@ -1098,12 +1097,7 @@ pub(crate) mod tests {
 		assert_eq!(db.cache().get_at(b"test", &BlockId::Number(0)), None);
 
 		// insert genesis block (no value for cache is provided)
-		let mut genesis_hash = None;
-		insert_block(&db, HashMap::new(), || {
-			let header = default_header(&Default::default(), 0);
-			genesis_hash = Some(header.hash());
-			header
-		});
+		insert_block(&db, HashMap::new(), || default_header(&Default::default(), 0));
 
 		// after genesis is inserted => None
 		assert_eq!(db.cache().get_at(b"test", &BlockId::Number(0)), None);
@@ -1112,6 +1106,6 @@ pub(crate) mod tests {
 		db.cache().initialize(b"test", vec![42]).unwrap();
 
 		// after genesis is inserted + cache is initialized => Some
-		assert_eq!(db.cache().get_at(b"test", &BlockId::Number(0)), Some(((0, genesis_hash.unwrap()), None, vec![42])));
+		assert_eq!(db.cache().get_at(b"test", &BlockId::Number(0)), Some(vec![42]));
 	}
 }

core/client/src/blockchain.rs

@@ -105,14 +105,8 @@ pub trait Cache<Block: BlockT>: Send + Sync {
 	/// The operation should be performed once before anything else is inserted in the cache.
 	/// Otherwise cache may end up in inconsistent state.
 	fn initialize(&self, key: &well_known_cache_keys::Id, value_at_genesis: Vec<u8>) -> Result<()>;
-	/// Returns cached value valid at given block.
-	///
-	/// Returned tuple is the range where value has been active and the value itself.
-	fn get_at(
-		&self,
-		key: &well_known_cache_keys::Id,
-		block: &BlockId<Block>,
-	) -> Option<((NumberFor<Block>, Block::Hash), Option<(NumberFor<Block>, Block::Hash)>, Vec<u8>)>;
+	/// Returns cached value by the given key.
+	fn get_at(&self, key: &well_known_cache_keys::Id, block: &BlockId<Block>) -> Option<Vec<u8>>;
 }
 
 /// Blockchain info

core/consensus/aura/src/lib.rs

@@ -623,7 +623,7 @@ fn initialize_authorities_cache<A, B, C>(client: &C) -> Result<(), ConsensusErro
 	let genesis_id = BlockId::Number(Zero::zero());
 	let genesis_authorities: Option<Vec<A>> = cache
 		.get_at(&well_known_cache_keys::AUTHORITIES, &genesis_id)
-		.and_then(|(_, _, v)| Decode::decode(&mut &v[..]));
+		.and_then(|v| Decode::decode(&mut &v[..]));
 	if genesis_authorities.is_some() {
 		return Ok(());
 	}
@@ -651,7 +651,7 @@ fn authorities<A, B, C>(client: &C, at: &BlockId<B>) -> Result<Vec<A>, Consensus
 		.cache()
 		.and_then(|cache| cache
 			.get_at(&well_known_cache_keys::AUTHORITIES, at)
-			.and_then(|(_, _, v)| Decode::decode(&mut &v[..]))
+			.and_then(|v| Decode::decode(&mut &v[..]))
 		)
 		.or_else(|| AuraApi::authorities(&*client.runtime_api(), at).ok())
 		.ok_or_else(|| consensus_common::Error::InvalidAuthoritiesSet.into())

core/consensus/babe/src/lib.rs

@@ -770,6 +770,7 @@ impl MaybeSpanEpoch {
 		}
 	}
 
+	#[cfg(test)]
 	pub fn into_regular(self) -> Option<Epoch> {
 		match self {
 			MaybeSpanEpoch::Regular(epoch) => Some(epoch),
@@ -799,8 +800,8 @@ fn epoch_from_cache<B, C>(client: &C, at: &BlockId<B>) -> Option<MaybeSpanEpoch>
 	// we need to go back for maximum two steps
 	client.cache()
 		.and_then(|cache| cache
-			.get_at_and_skip(0, &well_known_cache_keys::EPOCH, at)
-			.and_then(|(_, _, _, v)| Decode::decode(&mut &v[..])))
+			.get_at(&well_known_cache_keys::EPOCH, at)
+			.and_then(|v| Decode::decode(&mut &v[..])))
 }
 
 /// Extract current epoch from runtime.
@@ -929,7 +930,7 @@ fn initialize_authorities_cache<B, C>(client: &C) -> Result<(), ConsensusError>
 	let genesis_id = BlockId::Number(Zero::zero());
 	let genesis_epoch: Option<MaybeSpanEpoch> = cache
 		.get_at(&well_known_cache_keys::EPOCH, &genesis_id)
-		.and_then(|(_, _, v)| Decode::decode(&mut &v[..]));
+		.and_then(|v| Decode::decode(&mut &v[..]));
 	if genesis_epoch.is_some() {
 		return Ok(());
 	}
@@ -1076,7 +1077,7 @@ impl<B, E, Block, I, RA, PRA> BlockImport<Block> for BabeBlockImport<B, E, Block
 			&is_descendent_of,
 			&|epoch| epoch.start_slot <= slot_number,
 		).map_err(|e| ConsensusError::from(ConsensusError::ClientImport(e.to_string())))?;
-println!("=== ENACTED_EPOCH: {:?}", enacted_epoch);
+
 		let check_roots = || -> Result<bool, ConsensusError> {
 			// this can only happen when the chain starts, since there's no
 			// epoch change at genesis. afterwards every time we expect an epoch