Zingo sync scan transaction

libtonode-tests/Cargo.toml

@@ -33,3 +33,6 @@ tempfile.workspace = true
 tracing-subscriber.workspace = true
 proptest.workspace = true
 bech32 = "0.11.0"
+
+[dev-dependencies]
+rustls.workspace = true

libtonode-tests/tests/sync.rs

@@ -12,6 +12,9 @@ use zingolib::{
 #[ignore = "too slow, and flakey"]
 #[tokio::test]
 async fn sync_mainnet_test() {
+    rustls::crypto::ring::default_provider()
+        .install_default()
+        .expect("Ring to work as a default");
     tracing_subscriber::fmt().init();
 
     let uri = construct_lightwalletd_uri(Some(DEFAULT_LIGHTWALLETD_SERVER.to_string()));
@@ -62,6 +65,7 @@ async fn sync_test() {
     .await
     .unwrap();
 
+    dbg!(recipient.wallet.wallet_transactions());
     dbg!(recipient.wallet.wallet_blocks());
     dbg!(recipient.wallet.nullifier_map());
     dbg!(recipient.wallet.sync_state());

zingo-sync/src/client.rs

@@ -2,16 +2,19 @@
 
 use std::ops::Range;
 
+use tokio::sync::{mpsc::UnboundedSender, oneshot};
+
 use zcash_client_backend::{
     data_api::chain::ChainState,
     proto::{
         compact_formats::CompactBlock,
         service::{BlockId, TreeState},
     },
 };
-use zcash_primitives::consensus::BlockHeight;
-
-use tokio::sync::{mpsc::UnboundedSender, oneshot};
+use zcash_primitives::{
+    consensus::BlockHeight,
+    transaction::{Transaction, TxId},
+};
 
 pub mod fetch;
 
@@ -26,6 +29,8 @@ pub enum FetchRequest {
     CompactBlockRange(oneshot::Sender<Vec<CompactBlock>>, Range<BlockHeight>),
     /// Gets the tree states for a specified block height..
     TreeState(oneshot::Sender<TreeState>, BlockHeight),
+    /// Get a full transaction by txid.
+    Transaction(oneshot::Sender<(Transaction, BlockHeight)>, TxId),
 }
 
 /// Gets the height of the blockchain from the server.
@@ -34,7 +39,7 @@ pub enum FetchRequest {
 pub async fn get_chain_height(
     fetch_request_sender: UnboundedSender<FetchRequest>,
 ) -> Result<BlockHeight, ()> {
-    let (sender, receiver) = oneshot::channel::<BlockId>();
+    let (sender, receiver) = oneshot::channel();
     fetch_request_sender
         .send(FetchRequest::ChainTip(sender))
         .unwrap();
@@ -49,22 +54,22 @@ pub async fn get_compact_block_range(
     fetch_request_sender: UnboundedSender<FetchRequest>,
     block_range: Range<BlockHeight>,
 ) -> Result<Vec<CompactBlock>, ()> {
-    let (sender, receiver) = oneshot::channel::<Vec<CompactBlock>>();
+    let (sender, receiver) = oneshot::channel();
     fetch_request_sender
         .send(FetchRequest::CompactBlockRange(sender, block_range))
         .unwrap();
     let compact_blocks = receiver.await.unwrap();
 
     Ok(compact_blocks)
 }
-/// Gets the frontiers for a specified block height..
+/// Gets the frontiers for a specified block height.
 ///
 /// Requires [`crate::client::fetch::fetch`] to be running concurrently, connected via the `fetch_request` channel.
 pub async fn get_frontiers(
     fetch_request_sender: UnboundedSender<FetchRequest>,
     block_height: BlockHeight,
 ) -> Result<ChainState, ()> {
-    let (sender, receiver) = oneshot::channel::<TreeState>();
+    let (sender, receiver) = oneshot::channel();
     fetch_request_sender
         .send(FetchRequest::TreeState(sender, block_height))
         .unwrap();
@@ -73,3 +78,18 @@ pub async fn get_frontiers(
 
     Ok(frontiers)
 }
+/// Gets a full transaction for a specified txid.
+///
+/// Requires [`crate::client::fetch::fetch`] to be running concurrently, connected via the `fetch_request` channel.
+pub async fn get_transaction_and_block_height(
+    fetch_request_sender: UnboundedSender<FetchRequest>,
+    txid: TxId,
+) -> Result<(Transaction, BlockHeight), ()> {
+    let (sender, receiver) = oneshot::channel();
+    fetch_request_sender
+        .send(FetchRequest::Transaction(sender, txid))
+        .unwrap();
+    let transaction_and_block_height = receiver.await.unwrap();
+
+    Ok(transaction_and_block_height)
+}

zingo-sync/src/client/fetch.rs

@@ -8,10 +8,13 @@ use zcash_client_backend::proto::{
     compact_formats::CompactBlock,
     service::{
         compact_tx_streamer_client::CompactTxStreamerClient, BlockId, BlockRange, ChainSpec,
-        TreeState,
+        TreeState, TxFilter,
     },
 };
-use zcash_primitives::consensus::BlockHeight;
+use zcash_primitives::{
+    consensus::{self, BlockHeight, BranchId},
+    transaction::{Transaction, TxId},
+};
 
 use crate::client::FetchRequest;
 
@@ -24,6 +27,7 @@ use crate::client::FetchRequest;
 pub async fn fetch(
     mut fetch_request_receiver: UnboundedReceiver<FetchRequest>,
     mut client: CompactTxStreamerClient<zingo_netutils::UnderlyingService>,
+    consensus_parameters: impl consensus::Parameters,
 ) -> Result<(), ()> {
     let mut fetch_request_queue: Vec<FetchRequest> = Vec::new();
 
@@ -37,7 +41,9 @@ pub async fn fetch(
         let fetch_request = select_fetch_request(&mut fetch_request_queue);
 
         if let Some(request) = fetch_request {
-            fetch_from_server(&mut client, request).await.unwrap();
+            fetch_from_server(&mut client, &consensus_parameters, request)
+                .await
+                .unwrap();
         }
     }
 }
@@ -91,40 +97,46 @@ fn select_fetch_request(fetch_request_queue: &mut Vec<FetchRequest>) -> Option<F
 //
 async fn fetch_from_server(
     client: &mut CompactTxStreamerClient<zingo_netutils::UnderlyingService>,
+    parameters: &impl consensus::Parameters,
     fetch_request: FetchRequest,
 ) -> Result<(), ()> {
     match fetch_request {
         FetchRequest::ChainTip(sender) => {
             tracing::info!("Fetching chain tip.");
-            let block_id = get_latest_block(client).await;
+            let block_id = get_latest_block(client).await.unwrap();
             sender.send(block_id).unwrap();
         }
         FetchRequest::CompactBlockRange(sender, block_range) => {
             tracing::info!("Fetching compact blocks. {:?}", &block_range);
-            let compact_blocks = get_block_range(client, block_range).await;
+            let compact_blocks = get_block_range(client, block_range).await.unwrap();
             sender.send(compact_blocks).unwrap();
         }
         FetchRequest::TreeState(sender, block_height) => {
             tracing::info!("Fetching tree state. {:?}", &block_height);
-            let tree_state = get_tree_state(client, block_height).await;
+            let tree_state = get_tree_state(client, block_height).await.unwrap();
             sender.send(tree_state).unwrap();
         }
+        FetchRequest::Transaction(sender, txid) => {
+            tracing::info!("Fetching transaction. {:?}", txid);
+            let transaction = get_transaction(client, parameters, txid).await.unwrap();
+            sender.send(transaction).unwrap();
+        }
     }
 
     Ok(())
 }
 
 async fn get_latest_block(
     client: &mut CompactTxStreamerClient<zingo_netutils::UnderlyingService>,
-) -> BlockId {
+) -> Result<BlockId, ()> {
     let request = tonic::Request::new(ChainSpec {});
 
-    client.get_latest_block(request).await.unwrap().into_inner()
+    Ok(client.get_latest_block(request).await.unwrap().into_inner())
 }
 async fn get_block_range(
     client: &mut CompactTxStreamerClient<zingo_netutils::UnderlyingService>,
     block_range: Range<BlockHeight>,
-) -> Vec<CompactBlock> {
+) -> Result<Vec<CompactBlock>, ()> {
     let mut compact_blocks: Vec<CompactBlock> =
         Vec::with_capacity(u64::from(block_range.end - block_range.start) as usize);
 
@@ -144,16 +156,39 @@ async fn get_block_range(
         compact_blocks.push(compact_block);
     }
 
-    compact_blocks
+    Ok(compact_blocks)
 }
 async fn get_tree_state(
     client: &mut CompactTxStreamerClient<zingo_netutils::UnderlyingService>,
     block_height: BlockHeight,
-) -> TreeState {
+) -> Result<TreeState, ()> {
     let request = tonic::Request::new(BlockId {
         height: block_height.into(),
         hash: vec![],
     });
 
-    client.get_tree_state(request).await.unwrap().into_inner()
+    Ok(client.get_tree_state(request).await.unwrap().into_inner())
+}
+
+async fn get_transaction(
+    client: &mut CompactTxStreamerClient<zingo_netutils::UnderlyingService>,
+    parameters: &impl consensus::Parameters,
+    txid: TxId,
+) -> Result<(Transaction, BlockHeight), ()> {
+    let request = tonic::Request::new(TxFilter {
+        block: None,
+        index: 0,
+        hash: txid.as_ref().to_vec(),
+    });
+
+    let raw_transaction = client.get_transaction(request).await.unwrap().into_inner();
+    let block_height = BlockHeight::from_u32(raw_transaction.height as u32);
+
+    let transaction = Transaction::read(
+        &raw_transaction.data[..],
+        BranchId::for_height(parameters, block_height),
+    )
+    .unwrap();
+
+    Ok((transaction, block_height))
 }

zingo-sync/src/lib.rs

@@ -4,10 +4,10 @@
 //! Entrypoint: [`crate::sync::sync`]
 
 pub mod client;
-pub mod interface;
 pub(crate) mod keys;
 #[allow(missing_docs)]
 pub mod primitives;
 pub(crate) mod scan;
 pub mod sync;
+pub mod traits;
 pub mod witness;