Merge branch 'refs/heads/lmdb_update' into grim

Author: ardocrat

Cargo.lock

@@ -150,8 +150,8 @@ pub struct Chain {
 	store: Arc<store::ChainStore>,
 	adapter: Arc<dyn ChainAdapter + Send + Sync>,
 	orphans: Arc<OrphanBlockPool>,
-	txhashset: Arc<RwLock<txhashset::TxHashSet>>,
-	header_pmmr: Arc<RwLock<txhashset::PMMRHandle<BlockHeader>>>,
+	txhashset: Arc<RwLock<TxHashSet>>,
+	header_pmmr: Arc<RwLock<PMMRHandle<BlockHeader>>>,
 	pibd_segmenter: Arc<RwLock<Option<Segmenter>>>,
 	pibd_desegmenter: Arc<RwLock<Option<Desegmenter>>>,
 	// POW verification function
@@ -189,9 +189,9 @@ impl Chain {
 		// Initialize the output_pos index based on UTXO set
 		// and NRD kernel_pos index based recent kernel history.
 		{
-			let batch = store.batch()?;
-			txhashset.init_output_pos_index(&header_pmmr, &batch)?;
-			txhashset.init_recent_kernel_pos_index(&header_pmmr, &batch)?;
+			let mut batch = store.batch()?;
+			txhashset.init_output_pos_index(&header_pmmr, &mut batch)?;
+			txhashset.init_recent_kernel_pos_index(&header_pmmr, &mut batch)?;
 			batch.commit()?;
 		}
 
@@ -275,7 +275,7 @@ impl Chain {
 	pub fn reset_chain_head_to_genesis(&self) -> Result<(), Error> {
 		let mut header_pmmr = self.header_pmmr.write();
 		let mut txhashset = self.txhashset.write();
-		let batch = self.store.batch()?;
+		let mut batch = self.store.batch()?;
 
 		// Change head back to genesis
 		{
@@ -314,7 +314,7 @@ impl Chain {
 
 	/// Reset PIBD head
 	pub fn reset_pibd_head(&self) -> Result<(), Error> {
-		let batch = self.store.batch()?;
+		let mut batch = self.store.batch()?;
 		batch.save_pibd_head(&self.genesis().into())?;
 		Ok(())
 	}
@@ -530,9 +530,9 @@ impl Chain {
 	pub fn new_ctx<'a>(
 		&self,
 		opts: Options,
-		batch: store::Batch<'a>,
-		header_pmmr: &'a mut txhashset::PMMRHandle<BlockHeader>,
-		txhashset: &'a mut txhashset::TxHashSet,
+		batch: Batch<'a>,
+		header_pmmr: &'a mut PMMRHandle<BlockHeader>,
+		txhashset: &'a mut TxHashSet,
 	) -> Result<pipe::BlockContext<'a>, Error> {
 		let denylist = self.denylist.read().clone();
 		Ok(pipe::BlockContext {
@@ -832,7 +832,7 @@ impl Chain {
 		&self,
 		header: &BlockHeader,
 		ext: &mut ExtensionPair,
-		batch: &Batch,
+		batch: &mut Batch,
 	) -> Result<BlockHeader, Error> {
 		let denylist = self.denylist.read().clone();
 		pipe::rewind_and_apply_fork(header, ext, batch, &|header| {
@@ -846,7 +846,7 @@ impl Chain {
 		&self,
 		header: &BlockHeader,
 		ext: &mut HeaderExtension,
-		batch: &Batch,
+		batch: &mut Batch,
 	) -> Result<(), Error> {
 		let denylist = self.denylist.read().clone();
 		pipe::rewind_and_apply_header_fork(header, ext, batch, &|header| {
@@ -1015,7 +1015,7 @@ impl Chain {
 	fn validate_kernel_history(
 		&self,
 		header: &BlockHeader,
-		txhashset: &txhashset::TxHashSet,
+		txhashset: &TxHashSet,
 	) -> Result<(), Error> {
 		debug!("validate_kernel_history: rewinding and validating kernel history (readonly)");
 
@@ -1151,11 +1151,11 @@ impl Chain {
 			self.validate_kernel_history(&header, &txhashset)?;
 
 			let header_pmmr = self.header_pmmr.read();
-			let batch = self.store.batch()?;
+			let mut batch = self.store.batch()?;
 			txhashset.verify_kernel_pos_index(
 				&self.genesis.header,
 				&header_pmmr,
-				&batch,
+				&mut batch,
 				None,
 				None,
 			)?;
@@ -1213,10 +1213,10 @@ impl Chain {
 		}
 
 		// Rebuild our output_pos index in the db based on fresh UTXO set.
-		txhashset.init_output_pos_index(&header_pmmr, &batch)?;
+		txhashset.init_output_pos_index(&header_pmmr, &mut batch)?;
 
 		// Rebuild our NRD kernel_pos index based on recent kernel history.
-		txhashset.init_recent_kernel_pos_index(&header_pmmr, &batch)?;
+		txhashset.init_recent_kernel_pos_index(&header_pmmr, &mut batch)?;
 
 		// Commit all the changes to the db.
 		batch.commit()?;
@@ -1257,9 +1257,9 @@ impl Chain {
 	/// *Only* runs if we are not in archive mode.
 	fn remove_historical_blocks(
 		&self,
-		header_pmmr: &txhashset::PMMRHandle<BlockHeader>,
+		header_pmmr: &PMMRHandle<BlockHeader>,
 		archive_header: BlockHeader,
-		batch: &store::Batch<'_>,
+		batch: &mut Batch<'_>,
 	) -> Result<(), Error> {
 		if self.archive_mode() {
 			return Ok(());
@@ -1345,7 +1345,7 @@ impl Chain {
 		// Take a write lock on the txhashet and start a new writeable db batch.
 		let header_pmmr = self.header_pmmr.read();
 		let mut txhashset = self.txhashset.write();
-		let batch = self.store.batch()?;
+		let mut batch = self.store.batch()?;
 
 		// Compact the txhashset itself (rewriting the pruned backend files).
 		{
@@ -1361,15 +1361,15 @@ impl Chain {
 
 		// If we are not in archival mode remove historical blocks from the db.
 		if !self.archive_mode() {
-			self.remove_historical_blocks(&header_pmmr, archive_header, &batch)?;
+			self.remove_historical_blocks(&header_pmmr, archive_header, &mut batch)?;
 		}
 
 		// Make sure our output_pos index is consistent with the UTXO set.
-		txhashset.init_output_pos_index(&header_pmmr, &batch)?;
+		txhashset.init_output_pos_index(&header_pmmr, &mut batch)?;
 
 		// TODO - Why is this part of chain compaction?
 		// Rebuild our NRD kernel_pos index based on recent kernel history.
-		txhashset.init_recent_kernel_pos_index(&header_pmmr, &batch)?;
+		txhashset.init_recent_kernel_pos_index(&header_pmmr, &mut batch)?;
 
 		// Commit all the above db changes.
 		batch.commit()?;
@@ -1439,7 +1439,8 @@ impl Chain {
 			0
 		} else {
 			self.get_header_by_height(start_block_height - 1)?
-				.output_mmr_size + 1
+				.output_mmr_size
+				+ 1
 		};
 		let end_mmr_size = self.get_header_by_height(end_block_height)?.output_mmr_size;
 		Ok((start_mmr_size, end_mmr_size))

chain/src/chain.rs

@@ -108,23 +108,28 @@ pub trait ListIndex {
 	/// Push a pos onto the list for the specified commitment.
 	fn push_pos(
 		&self,
-		batch: &Batch<'_>,
+		batch: &mut Batch<'_>,
 		commit: Commitment,
 		new_pos: <Self::Entry as ListIndexEntry>::Pos,
 	) -> Result<(), Error>;
 
 	/// Pop a pos off the list for the specified commitment.
 	fn pop_pos(
 		&self,
-		batch: &Batch<'_>,
+		batch: &mut Batch<'_>,
 		commit: Commitment,
 	) -> Result<Option<<Self::Entry as ListIndexEntry>::Pos>, Error>;
 }
 
 /// Supports "rewind" given the provided commit and a pos to rewind back to.
 pub trait RewindableListIndex {
 	/// Rewind the index for the given commitment to the specified position.
-	fn rewind(&self, batch: &Batch<'_>, commit: Commitment, rewind_pos: u64) -> Result<(), Error>;
+	fn rewind(
+		&self,
+		batch: &mut Batch<'_>,
+		commit: Commitment,
+		rewind_pos: u64,
+	) -> Result<(), Error>;
 }
 
 /// A pruneable list index supports pruning of old data from the index lists.
@@ -133,15 +138,20 @@ pub trait RewindableListIndex {
 pub trait PruneableListIndex: ListIndex {
 	/// Clear all data from the index.
 	/// Used when rebuilding the index.
-	fn clear(&self, batch: &Batch<'_>) -> Result<(), Error>;
+	fn clear(&self, batch: &mut Batch<'_>) -> Result<(), Error>;
 
 	/// Prune old data.
-	fn prune(&self, batch: &Batch<'_>, commit: Commitment, cutoff_pos: u64) -> Result<(), Error>;
+	fn prune(
+		&self,
+		batch: &mut Batch<'_>,
+		commit: Commitment,
+		cutoff_pos: u64,
+	) -> Result<(), Error>;
 
 	/// Pop a pos off the back of the list (used for pruning old data).
 	fn pop_pos_back(
 		&self,
-		batch: &Batch<'_>,
+		batch: &mut Batch<'_>,
 		commit: Commitment,
 	) -> Result<Option<<Self::Entry as ListIndexEntry>::Pos>, Error>;
 }
@@ -255,7 +265,7 @@ where
 		}
 	}
 
-	fn push_pos(&self, batch: &Batch<'_>, commit: Commitment, new_pos: T) -> Result<(), Error> {
+	fn push_pos(&self, batch: &mut Batch<'_>, commit: Commitment, new_pos: T) -> Result<(), Error> {
 		match self.get_list(batch, commit)? {
 			None => {
 				let list = ListWrapper::Single { pos: new_pos };
@@ -327,7 +337,7 @@ where
 	/// Pop the head of the list.
 	/// Returns the output_pos.
 	/// Returns None if list was empty.
-	fn pop_pos(&self, batch: &Batch<'_>, commit: Commitment) -> Result<Option<T>, Error> {
+	fn pop_pos(&self, batch: &mut Batch<'_>, commit: Commitment) -> Result<Option<T>, Error> {
 		match self.get_list(batch, commit)? {
 			None => Ok(None),
 			Some(ListWrapper::Single { pos }) => {
@@ -373,7 +383,12 @@ where
 
 /// List index that supports rewind.
 impl<T: PosEntry> RewindableListIndex for MultiIndex<T> {
-	fn rewind(&self, batch: &Batch<'_>, commit: Commitment, rewind_pos: u64) -> Result<(), Error> {
+	fn rewind(
+		&self,
+		batch: &mut Batch<'_>,
+		commit: Commitment,
+		rewind_pos: u64,
+	) -> Result<(), Error> {
 		while self
 			.peek_pos(batch, commit)?
 			.map(|x| x.pos() > rewind_pos)
@@ -386,7 +401,7 @@ impl<T: PosEntry> RewindableListIndex for MultiIndex<T> {
 }
 
 impl<T: PosEntry> PruneableListIndex for MultiIndex<T> {
-	fn clear(&self, batch: &Batch<'_>) -> Result<(), Error> {
+	fn clear(&self, batch: &mut Batch<'_>) -> Result<(), Error> {
 		let mut list_count = 0;
 		let mut entry_count = 0;
 		let prefix = to_key(self.list_prefix, "");
@@ -409,7 +424,7 @@ impl<T: PosEntry> PruneableListIndex for MultiIndex<T> {
 	/// Pruning will be more performant than full rebuild but not yet necessary.
 	fn prune(
 		&self,
-		_batch: &Batch<'_>,
+		_batch: &mut Batch<'_>,
 		_commit: Commitment,
 		_cutoff_pos: u64,
 	) -> Result<(), Error> {
@@ -420,7 +435,7 @@ impl<T: PosEntry> PruneableListIndex for MultiIndex<T> {
 
 	/// Pop off the back/tail of the linked list.
 	/// Used when pruning old data.
-	fn pop_pos_back(&self, batch: &Batch<'_>, commit: Commitment) -> Result<Option<T>, Error> {
+	fn pop_pos_back(&self, batch: &mut Batch<'_>, commit: Commitment) -> Result<Option<T>, Error> {
 		match self.get_list(batch, commit)? {
 			None => Ok(None),
 			Some(ListWrapper::Single { pos }) => {