Merge pull request zingolabs#1279 from fluidvanadium/statassert

Generic Test Status

darkside-tests/src/chain_generics.rs

@@ -124,5 +124,9 @@ pub(crate) mod impl_conduct_chain_for_darkside_environment {
             self.staged_blockheight = self.staged_blockheight + 1;
             self.apply_blocks(u64::from(self.staged_blockheight)).await;
         }
+
+        fn get_chain_height(&mut self) -> u32 {
+            self.staged_blockheight.into()
+        }
     }
 }

libtonode-tests/tests/chain_generics.rs

@@ -266,6 +266,13 @@ mod chain_generics {
                     target
                 );
             }
+
+            fn get_chain_height(&mut self) -> u32 {
+                self.scenario_builder
+                    .regtest_manager
+                    .get_current_height()
+                    .unwrap()
+            }
         }
     }
 }

zingo-status/src/confirmation_status.rs

@@ -8,7 +8,7 @@ use zcash_primitives::consensus::BlockHeight;
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub enum ConfirmationStatus {
     /// The transaction is pending confirmation to the zcash blockchain. It may be waiting in the mempool.
-    /// The BlockHeight is the height of the chain as the transaction was broadcast.
+    /// The BlockHeight is the 1 + the height of the chain as the transaction was broadcast, i.e. the target height.
     Pending(BlockHeight),
     /// The transaction has been included in at-least one block mined to the zcash blockchain.
     /// The height of a confirmed block that contains the transaction.

zingo-testutils/Cargo.toml

@@ -14,6 +14,7 @@ zingoconfig = { path = "../zingoconfig" }
 zingolib = { path = "../zingolib" }
 zingo-netutils = { path = "../zingo-netutils", features = ["test-features"] }
 zingo-testvectors = { path = "../zingo-testvectors" }
+zingo-status = { path = "../zingo-status" }
 
 zcash_client_backend = { workspace = true }
 zcash_primitives = { workspace = true }

zingo-testutils/src/assertions.rs

@@ -4,6 +4,8 @@ use nonempty::NonEmpty;
 
 use zcash_client_backend::proposal::Proposal;
 use zcash_primitives::transaction::TxId;
+
+use zingo_status::confirmation_status::ConfirmationStatus;
 use zingolib::{lightclient::LightClient, wallet::notes::query::OutputQuery};
 
 /// currently checks:
@@ -12,10 +14,11 @@ use zingolib::{lightclient::LightClient, wallet::notes::query::OutputQuery};
 /// 3. if the fee from the calculate_transaction_fee matches the sum of the per-step fees
 /// this currently fails for any broadcast but not confirmed transaction: it seems like get_transaction_fee does not recognize pending spends
 /// returns the total fee for the transfer
-pub async fn assert_sender_fee<NoteId>(
+pub async fn assert_record_fee_and_status<NoteId>(
     client: &LightClient,
     proposal: &Proposal<zcash_primitives::transaction::fees::zip317::FeeRule, NoteId>,
     txids: &NonEmpty<TxId>,
+    expected_status: ConfirmationStatus,
 ) -> u64 {
     let records = &client
         .wallet
@@ -30,6 +33,8 @@ pub async fn assert_sender_fee<NoteId>(
     for (i, step) in proposal.steps().iter().enumerate() {
         let record = records.get(&txids[i]).expect("sender must recognize txid");
         // does this record match this step?
+        // we can check that it has the expected status
+        assert_eq!(record.status, expected_status);
         // may fail in uncertain ways if used on a transaction we dont have an OutgoingViewingKey for
         let recorded_fee = records.calculate_transaction_fee(record).unwrap();
         assert_eq!(recorded_fee, step.balance().fee_required().into_u64());

zingo-testutils/src/chain_generics/conduct_chain.rs

@@ -23,6 +23,9 @@ pub trait ConductChain {
     /// and confirming transactions that were received by the server
     async fn bump_chain(&mut self);
 
+    /// gets the height. does not yet need to be async
+    fn get_chain_height(&mut self) -> u32;
+
     /// builds a client and funds it in orchard and syncs it
     async fn fund_client_orchard(&mut self, value: u64) -> LightClient {
         let faucet = self.create_faucet().await;

zingo-testutils/src/chain_generics/fixtures.rs

@@ -1,5 +1,7 @@
 //! these functions are each meant to be 'test-in-a-box'
 //! simply plug in a mock server as a chain conductor and provide some values
+use std::sync::Arc;
+
 use zcash_client_backend::PoolType;
 use zcash_client_backend::PoolType::Shielded;
 use zcash_client_backend::PoolType::Transparent;
@@ -8,6 +10,7 @@ use zcash_client_backend::ShieldedProtocol::Orchard;
 use zcash_client_backend::ShieldedProtocol::Sapling;
 use zcash_primitives::transaction::fees::zip317::MARGINAL_FEE;
 
+use zingolib::lightclient::LightClient;
 use zingolib::wallet::notes::query::OutputSpendStatusQuery;
 use zingolib::wallet::notes::{query::OutputPoolQuery, OutputInterface};
 use zingolib::wallet::{data::summaries::ValueTransferKind, notes::query::OutputQuery};
@@ -31,7 +34,7 @@ where
     println!("client is ready to send");
 
     let recipient = environment.create_client().await;
-    with_assertions::propose_send_bump_sync_recipient(
+    with_assertions::propose_send_bump_sync_all_recipients(
         &mut environment,
         &sender,
         vec![
@@ -49,6 +52,7 @@ where
             ),
             (&sender, PoolType::Transparent, send_value_self, None),
         ],
+        false,
     )
     .await;
     assert_eq!(sender.value_transfers().await.0.len(), 3);
@@ -70,10 +74,11 @@ where
         ValueTransferKind::Received
     );
 
-    with_assertions::propose_send_bump_sync_recipient(
+    with_assertions::propose_send_bump_sync_all_recipients(
         &mut environment,
         &sender,
         vec![(&sender, PoolType::Shielded(Orchard), send_value_self, None)],
+        false,
     )
     .await;
     assert_eq!(sender.value_transfers().await.0.len(), 4);
@@ -82,7 +87,7 @@ where
         ValueTransferKind::SendToSelf
     );
 
-    with_assertions::propose_shield_bump_sync(&mut environment, &sender).await;
+    with_assertions::propose_shield_bump_sync(&mut environment, &sender, false).await;
     assert_eq!(sender.value_transfers().await.0.len(), 5);
     assert_eq!(
         sender.value_transfers().await.0[4].kind(),
@@ -129,10 +134,11 @@ where
 
     println!("recipient ready");
 
-    let recorded_fee = with_assertions::propose_send_bump_sync_recipient(
+    let recorded_fee = with_assertions::propose_send_bump_sync_all_recipients(
         &mut environment,
         &sender,
         vec![(&recipient, pooltype, send_value, None)],
+        false,
     )
     .await;
 
@@ -149,13 +155,14 @@ where
     let secondary = environment.create_client().await;
 
     assert_eq!(
-        with_assertions::propose_send_bump_sync_recipient(
+        with_assertions::propose_send_bump_sync_all_recipients(
             &mut environment,
             &primary,
             vec![
                 (&secondary, Shielded(Orchard), 1, None),
                 (&secondary, Shielded(Orchard), 29_999, None)
-            ]
+            ],
+            false,
         )
         .await,
         3 * MARGINAL_FEE.into_u64()
@@ -175,28 +182,30 @@ where
 
     for _ in 0..n {
         assert_eq!(
-            with_assertions::propose_send_bump_sync_recipient(
+            with_assertions::propose_send_bump_sync_all_recipients(
                 &mut environment,
                 &primary,
                 vec![
                     (&secondary, Transparent, 100_000, None),
                     (&secondary, Transparent, 4_000, None)
                 ],
+                false,
             )
             .await,
             MARGINAL_FEE.into_u64() * 4
         );
 
         assert_eq!(
-            with_assertions::propose_shield_bump_sync(&mut environment, &secondary).await,
+            with_assertions::propose_shield_bump_sync(&mut environment, &secondary, false,).await,
             MARGINAL_FEE.into_u64() * 3
         );
 
         assert_eq!(
-            with_assertions::propose_send_bump_sync_recipient(
+            with_assertions::propose_send_bump_sync_all_recipients(
                 &mut environment,
                 &secondary,
                 vec![(&primary, Shielded(Orchard), 50_000, None)],
+                false,
             )
             .await,
             MARGINAL_FEE.into_u64() * 2
@@ -214,23 +223,25 @@ where
     let secondary = environment.create_client().await;
 
     assert_eq!(
-        with_assertions::propose_send_bump_sync_recipient(
+        with_assertions::propose_send_bump_sync_all_recipients(
             &mut environment,
             &primary,
             vec![
                 (&secondary, Shielded(Orchard), 1, None),
                 (&secondary, Shielded(Orchard), 99_999, None)
-            ]
+            ],
+            false,
         )
         .await,
         3 * MARGINAL_FEE.into_u64()
     );
 
     assert_eq!(
-        with_assertions::propose_send_bump_sync_recipient(
+        with_assertions::propose_send_bump_sync_all_recipients(
             &mut environment,
             &secondary,
-            vec![(&primary, Shielded(Orchard), 90_000, None)]
+            vec![(&primary, Shielded(Orchard), 90_000, None)],
+            false,
         )
         .await,
         2 * MARGINAL_FEE.into_u64()
@@ -247,23 +258,25 @@ where
     let secondary = environment.create_client().await;
 
     assert_eq!(
-        with_assertions::propose_send_bump_sync_recipient(
+        with_assertions::propose_send_bump_sync_all_recipients(
             &mut environment,
             &primary,
             vec![
                 (&secondary, Shielded(Orchard), 1, None),
                 (&secondary, Shielded(Orchard), 99_999, None)
-            ]
+            ],
+            false,
         )
         .await,
         3 * MARGINAL_FEE.into_u64()
     );
 
     assert_eq!(
-        with_assertions::propose_send_bump_sync_recipient(
+        with_assertions::propose_send_bump_sync_all_recipients(
             &mut environment,
             &secondary,
-            vec![(&primary, Shielded(Orchard), 30_000, None)]
+            vec![(&primary, Shielded(Orchard), 30_000, None)],
+            false,
         )
         .await,
         2 * MARGINAL_FEE.into_u64()
@@ -291,7 +304,7 @@ where
 
     // send a bunch of dust
     assert_eq!(
-        with_assertions::propose_send_bump_sync_recipient(
+        with_assertions::propose_send_bump_sync_all_recipients(
             &mut environment,
             &primary,
             vec![
@@ -306,17 +319,19 @@ where
                 (&secondary, Shielded(Orchard), 1_000, None),
                 (&secondary, Shielded(Orchard), 15_000, None),
             ],
+            false,
         )
         .await,
         11 * MARGINAL_FEE.into_u64()
     );
 
     // combine the only valid sapling note with the only valid orchard note to send
     assert_eq!(
-        with_assertions::propose_send_bump_sync_recipient(
+        with_assertions::propose_send_bump_sync_all_recipients(
             &mut environment,
             &secondary,
             vec![(&primary, Shielded(Orchard), 10_000, None),],
+            false,
         )
         .await,
         4 * MARGINAL_FEE.into_u64()
@@ -387,12 +402,13 @@ where
 
     // Send number_of_notes transfers in increasing 10_000 zat increments
     assert_eq!(
-        with_assertions::propose_send_bump_sync_recipient(
+        with_assertions::propose_send_bump_sync_all_recipients(
             &mut environment,
             &primary,
             transaction_1_values
                 .map(|value| (&secondary, Shielded(Sapling), value, None))
-                .collect()
+                .collect(),
+            false,
         )
         .await,
         expected_fee_for_transaction_1
@@ -436,10 +452,11 @@ where
         * MARGINAL_FEE.into_u64();
     // the second client selects notes to cover the transaction.
     assert_eq!(
-        with_assertions::propose_send_bump_sync_recipient(
+        with_assertions::propose_send_bump_sync_all_recipients(
             &mut environment,
             &secondary,
-            vec![(&primary, Shielded(Orchard), value_from_transaction_2, None)]
+            vec![(&primary, Shielded(Orchard), value_from_transaction_2, None)],
+            false,
         )
         .await,
         expected_fee_for_transaction_2
@@ -487,10 +504,11 @@ where
 
     let primary = environment.fund_client_orchard(1_000_000).await;
     let secondary = environment.create_client().await;
-    with_assertions::propose_send_bump_sync_recipient(
+    with_assertions::propose_send_bump_sync_all_recipients(
         &mut environment,
         &primary,
         vec![(&secondary, Shielded(shpool), 100_000 + make_change, None)],
+        false,
     )
     .await;
 
@@ -504,12 +522,24 @@ where
     //         .into_u64(),
     //     0
     // );
+
+    let ref_tertiary: Arc<LightClient> = Arc::new(tertiary);
+
+    // mempool monitor
+    let check_mempool = false;
+    if check_mempool {
+        LightClient::start_mempool_monitor(ref_tertiary.clone());
+        dbg!("mm started");
+        tokio::time::sleep(std::time::Duration::from_secs(5)).await;
+    }
+
     assert_eq!(
         expected_fee,
-        with_assertions::propose_send_bump_sync_recipient(
+        with_assertions::propose_send_bump_sync_all_recipients(
             &mut environment,
             &secondary,
-            vec![(&tertiary, pool, 100_000 - expected_fee, None)],
+            vec![(&ref_tertiary, pool, 100_000 - expected_fee, None)],
+            check_mempool,
         )
         .await
     );