#184 unconfirmed balance pr

src/lib.rs

@@ -164,6 +164,7 @@ pub async fn initialize(cli_args: cli_args::Args) -> Result<()> {
         cli_args.max_mempool_num_tx,
         latest_block.hash(),
     );
+
     let mut global_state_lock = GlobalStateLock::new(
         wallet_state,
         blockchain_state,

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

@@ -539,8 +539,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 =
@@ -998,7 +998,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);
@@ -1054,8 +1054,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

@@ -44,7 +44,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,
@@ -311,7 +311,7 @@ pub(crate) async 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.
-async fn create_block_transaction(
+pub(crate) async fn create_block_transaction(
     predecessor_block: &Block,
     global_state: &GlobalState,
     timestamp: Timestamp,
@@ -545,7 +545,7 @@ mod mine_loop_tests {
 
     #[traced_test]
     #[tokio::test]
-    async fn block_template_is_valid_test() {
+    async fn block_template_is_valid_test() -> Result<()> {
         // Verify that a block template made with transaction from the mempool is a valid block
         let network = Network::Main;
         let mut alice = mock_genesis_global_state(network, 2, WalletSecret::devnet_wallet()).await;
@@ -636,8 +636,11 @@ mod mine_loop_tests {
         // no need to inform wallet of expected utxos; block template validity
         // is what is being tested
 
-        alice.lock_guard_mut().await.mempool.insert(&tx_by_preminer);
-        assert_eq!(1, alice.lock_guard().await.mempool.len());
+        {
+            let mut alice_gsm = alice.lock_guard_mut().await;
+            alice_gsm.mempool_insert(tx_by_preminer).await?;
+            assert_eq!(1, alice_gsm.mempool.len());
+        }
 
         // Build transaction for block
         let (transaction_non_empty_mempool, _new_coinbase_sender_randomness) = {
@@ -667,6 +670,8 @@ mod mine_loop_tests {
                 .is_valid(&genesis_block, in_seven_months + Timestamp::seconds(2)),
             "Block template created by miner with non-empty mempool must be valid"
         );
+
+        Ok(())
     }
 
     /// This test mines a single block at height 1 on the regtest network

src/models/blockchain/transaction/transaction_output.rs

@@ -33,7 +33,7 @@ pub enum UtxoNotificationMedium {
 ///
 /// see also: [UtxoNotification]
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-enum UtxoNotifyMethod {
+pub(crate) enum UtxoNotifyMethod {
     /// the utxo notification should be transferred to recipient encrypted on the blockchain
     OnChain(ReceivingAddress),