broadcast insistor

darkside-tests/src/chain_generics.rs

@@ -14,6 +14,11 @@ use zingolib::testutils::int_to_shieldedprotocol;
 
 use crate::utils::scenarios::DarksideEnvironment;
 
+#[tokio::test]
+async fn simple_send_darkside() {
+    fixtures::simple_send::<DarksideEnvironment>(10_000, false).await;
+}
+
 proptest! {
     #![proptest_config(proptest::test_runner::Config::with_cases(4))]
     #[test]
@@ -50,12 +55,14 @@ pub(crate) mod conduct_chain {
     /// doesnt use the full extent of DarksideEnvironment, preferring to rely on server truths when ever possible.
     impl ConductChain for DarksideEnvironment {
         async fn setup() -> Self {
-            let elf = DarksideEnvironment::new(None).await;
+            let mut elf = DarksideEnvironment::new(None).await;
+            elf.stage_transaction(ABANDON_TO_DARKSIDE_SAP_10_000_000_ZAT)
+                .await;
             elf.darkside_connector
-                .stage_blocks_create(1, 1, 0)
+                .stage_blocks_create(2, 1, 0)
                 .await
                 .unwrap();
-            elf.darkside_connector.apply_staged(1).await.unwrap();
+            elf.darkside_connector.apply_staged(2).await.unwrap();
             elf
         }
 
@@ -65,8 +72,6 @@ pub(crate) mod conduct_chain {
         }
 
         async fn create_faucet(&mut self) -> LightClient {
-            self.stage_transaction(ABANDON_TO_DARKSIDE_SAP_10_000_000_ZAT)
-                .await;
             let zingo_config = self
                 .client_builder
                 .make_unique_data_dir_and_load_config(self.regtest_network);
@@ -87,7 +92,7 @@ pub(crate) mod conduct_chain {
 
         async fn bump_chain(&mut self) {
             let height_before =
-                zingolib::grpc_connector::get_latest_block(self.lightserver_uri().unwrap())
+                zingolib::grpc_connector::get_latest_block(&self.lightserver_uri().unwrap())
                     .await
                     .unwrap()
                     .height;

darkside-tests/tests/tests.rs

@@ -9,7 +9,6 @@ use testvectors::seeds::DARKSIDE_SEED;
 use tokio::time::sleep;
 use zcash_client_backend::PoolType::Shielded;
 use zcash_client_backend::ShieldedProtocol::Orchard;
-use zcash_primitives::consensus::BlockHeight;
 use zingo_status::confirmation_status::ConfirmationStatus;
 use zingolib::config::RegtestNetwork;
 use zingolib::get_base_address_macro;
@@ -18,6 +17,7 @@ use zingolib::lightclient::LightClient;
 use zingolib::lightclient::PoolBalances;
 use zingolib::testutils;
 use zingolib::testutils::chain_generics::conduct_chain::ConductChain;
+use zingolib::testutils::chain_generics::with_assertions::validate_send_result;
 use zingolib::testutils::scenarios::setup::ClientBuilder;
 use zingolib::wallet::notes::query::OutputQuery;
 
@@ -276,15 +276,15 @@ async fn transaction_disappears_before_mempool() {
 
     // a modified zingolib::testutils::chain_generics::with_assertions::follow_proposal block
     {
+        let txids = validate_send_result(&primary, txids).await.unwrap();
+
         let sender = &primary;
         let proposal = &proposal;
 
-        let server_height_at_send = BlockHeight::from(
-            grpc_connector::get_latest_block(environment.lightserver_uri().unwrap())
+        let server_height_at_send =
+            crate::grpc_connector::get_latest_block_height(&environment.lightserver_uri().unwrap())
                 .await
-                .unwrap()
-                .height as u32,
-        );
+                .unwrap();
 
         // check that each record has the expected fee and status, returning the fee
         let (sender_recorded_fees, (sender_recorded_outputs, sender_recorded_statuses)): (
@@ -362,7 +362,7 @@ async fn transaction_disappears_before_mempool() {
         for status in sender_confirmed_statuses {
             assert_eq!(
                 status,
-                ConfirmationStatus::Transmitted(server_height_at_send + 1)
+                ConfirmationStatus::Confirmed(server_height_at_send + 1)
             );
         }
     }

libtonode-tests/tests/chain_generics.proptest-regressions

@@ -0,0 +1,8 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+cc 64d91b23be1001070c6f03675388fb561aa34ca6cd9cac36b6f4850675789787 # shrinks to send_value = 0, sender_protocol = 1, receiver_pool = 0
+cc 0ad075771292fafd9cc5ae2a40401290d91e1829f4ad9e8e7fd636f7fd00db6e # shrinks to send_value = 0, change_value = 3383, sender_protocol = 1, receiver_pool = 1

libtonode-tests/tests/chain_generics.rs

@@ -4,6 +4,11 @@ use zingolib::testutils::{
     int_to_pooltype, int_to_shieldedprotocol,
 };
 
+#[tokio::test]
+async fn simple_send_libtonode() {
+    fixtures::simple_send::<LibtonodeEnvironment>(10_000, true).await;
+}
+
 proptest::proptest! {
     #![proptest_config(proptest::test_runner::Config::with_cases(4))]
     #[ignore = "hangs"]
@@ -21,6 +26,7 @@ proptest::proptest! {
      }
 }
 
+// extra mod. to be removed, and tests coalesced
 mod chain_generics {
     use zcash_client_backend::PoolType::Shielded;
     use zcash_client_backend::PoolType::Transparent;

zingolib/src/data.rs

@@ -1,4 +1,8 @@
 //! This is a mod for data structs that will be used across all sections of zingolib.
+
+use zcash_primitives::transaction::TxId;
+
+use crate::utils::conversion::TxIdFromHexEncodedStrError;
 pub mod proposal;
 pub mod witness_trees;
 
@@ -66,3 +70,34 @@ pub mod receivers {
         TransactionRequest::new(payments)
     }
 }
+
+#[allow(missing_docs)] // error types document themselves
+#[derive(Clone, Debug, thiserror::Error, PartialEq)]
+pub enum TxIdComparisonError {
+    #[error("Server returned TxId [{0}] which fails to decode with error: [{1:?}].")]
+    InvalidTxId(String, TxIdFromHexEncodedStrError),
+    /// please note that this error contains two arguments of the same type. Its possible to cause bugs by interpreting them in the opposite order.
+    #[error("Server returned TxId: [{0:?}], which does not match expected [{1:?}].")]
+    InconsistentTxId(TxId, TxId),
+}
+
+pub(crate) fn txid_comparison(
+    reported_string_txid: String,
+    original_txid: &TxId,
+) -> Result<TxId, TxIdComparisonError> {
+    match crate::utils::conversion::txid_from_hex_encoded_str(reported_string_txid.as_str()) {
+        Ok(reported_txid) => {
+            if *original_txid != reported_txid {
+                {
+                    Err(TxIdComparisonError::InconsistentTxId(
+                        reported_txid,
+                        *original_txid,
+                    ))
+                }
+            } else {
+                Ok(reported_txid)
+            }
+        }
+        Err(e) => Err(TxIdComparisonError::InvalidTxId(reported_string_txid, e)),
+    }
+}

zingolib/src/grpc_connector.rs

@@ -324,7 +324,7 @@ pub async fn get_trees(uri: http::Uri, height: u64) -> Result<TreeState, String>
 }
 
 /// get_latest_block GRPC call
-pub async fn get_latest_block(uri: http::Uri) -> Result<BlockId, String> {
+pub async fn get_latest_block(uri: &http::Uri) -> Result<BlockId, String> {
     let client = Arc::new(GrpcConnector::new(uri.clone()));
     let mut client = client
         .get_client()
@@ -341,6 +341,13 @@ pub async fn get_latest_block(uri: http::Uri) -> Result<BlockId, String> {
     Ok(response.into_inner())
 }
 
+/// ask LightWalletD server for latest block height
+pub async fn get_latest_block_height(uri: &http::Uri) -> Result<BlockHeight, String> {
+    Ok(BlockHeight::from_u32(
+        get_latest_block(uri).await?.height as u32,
+    ))
+}
+
 /// TODO: Add Doc Comment Here!
 pub async fn send_transaction(
     uri: http::Uri,

zingolib/src/lightclient.rs

@@ -89,23 +89,22 @@ pub struct LightWalletSendProgress {
 impl LightWalletSendProgress {
     /// TODO: Add Doc Comment Here!
     pub fn to_json(&self) -> JsonValue {
-        let last_result = self.progress.last_result.clone();
-        let tx_ids: Vec<String> = match &last_result {
-            Some(r) => {
-                let mut binding = r.clone().unwrap();
-                let binding = binding.as_array_mut();
-                let tx_json_values: Vec<String> = binding
-                    .unwrap()
-                    .iter()
-                    .map(|x| x.as_str().unwrap().to_string())
-                    .collect();
-                tx_json_values
-            }
-            None => vec![],
+        let opt_last_result = self.progress.last_result.clone();
+
+        let (tx_ids, error): (Vec<String>, Option<String>) = match &opt_last_result {
+            Some(last_result) => match last_result {
+                Ok(txids) => (
+                    txids
+                        .iter()
+                        .map(|txid| txid.to_string())
+                        .collect::<Vec<String>>(),
+                    None,
+                ),
+                Err(e) => (vec![], Some(e.to_string())),
+            },
+            None => (vec![], None),
         };
 
-        let error: Option<String> = last_result.and_then(|result| result.err());
-
         object! {
             "id" => self.progress.id,
             "sending" => self.progress.is_send_in_progress,