ignore unconfirmed spent input

src/locks/tokio/atomic_rw.rs

@@ -6,6 +6,7 @@ use futures::future::BoxFuture;
 use tokio::sync::RwLock;
 use tokio::sync::RwLockReadGuard;
 use tokio::sync::RwLockWriteGuard;
+use tokio::sync::TryLockError;
 
 use super::LockAcquisition;
 use super::LockCallbackFn;
@@ -240,6 +241,15 @@ impl<T> AtomicRw<T> {
         AtomicRwWriteGuard::new(guard, &self.lock_callback_info)
     }
 
+    /// Attempt to acquire write lock immediately.
+    ///
+    /// If the lock cannot be acquired without waiting, an error is returned.
+    pub fn try_lock_guard_mut(&mut self) -> Result<AtomicRwWriteGuard<T>, TryLockError> {
+        self.try_acquire_write_cb();
+        let guard = self.inner.try_write()?;
+        Ok(AtomicRwWriteGuard::new(guard, &self.lock_callback_info))
+    }
+
     /// Immutably access the data of type `T` in a closure and possibly return a result of type `R`
     ///
     /// # Examples

src/main_loop.rs

@@ -528,8 +528,8 @@ impl MainLoopHandler {
 
                 // Insert into mempool
                 global_state_mut
-                    .mempool
-                    .insert(&pt2m_transaction.transaction);
+                    .mempool_insert(pt2m_transaction.transaction.to_owned())
+                    .await?;
 
                 // send notification to peers
                 let transaction_notification: TransactionNotification =
@@ -970,7 +970,7 @@ impl MainLoopHandler {
                 // Handle mempool cleanup, i.e. removing stale/too old txs from mempool
                 _ = &mut mempool_cleanup_timer => {
                     debug!("Timer: mempool-cleaner job");
-                    self.global_state_lock.lock_mut(|s| s.mempool.prune_stale_transactions()).await;
+                    self.global_state_lock.lock_guard_mut().await.mempool_prune_stale_transactions().await?;
 
                     // Reset the timer to run this branch again in P seconds
                     mempool_cleanup_timer.as_mut().reset(tokio::time::Instant::now() + mempool_cleanup_timer_interval);
@@ -1026,8 +1026,10 @@ impl MainLoopHandler {
 
                 // insert transaction into mempool
                 self.global_state_lock
-                    .lock_mut(|s| s.mempool.insert(&transaction))
-                    .await;
+                    .lock_guard_mut()
+                    .await
+                    .mempool_insert(*transaction)
+                    .await?;
 
                 // do not shut down
                 Ok(false)

src/mine_loop.rs

@@ -51,7 +51,7 @@ use crate::util_types::mutator_set::mutator_set_accumulator::MutatorSetAccumulat
 const MOCK_MAX_BLOCK_SIZE: u32 = 1_000_000;
 
 /// Prepare a Block for mining
-fn make_block_template(
+pub(crate) fn make_block_template(
     previous_block: &Block,
     transaction: Transaction,
     mut block_timestamp: Timestamp,
@@ -299,7 +299,7 @@ fn make_coinbase_transaction(
 /// Create the transaction that goes into the block template. The transaction is
 /// built from the mempool and from the coinbase transaction. Also returns the
 /// "sender randomness" used in the coinbase transaction.
-fn create_block_transaction(
+pub(crate) fn create_block_transaction(
     latest_block: &Block,
     global_state: &GlobalState,
     timestamp: Timestamp,
@@ -603,8 +603,8 @@ mod mine_loop_tests {
             .await?;
 
         premine_receiver_global_state
-            .mempool
-            .insert(&tx_by_preminer);
+            .mempool_insert(tx_by_preminer)
+            .await?;
         assert_eq!(1, premine_receiver_global_state.mempool.len());
 
         // Build transaction