single scan test

Author: adityapk00

lib/src/blaze/test_utils.rs

@@ -15,6 +15,7 @@ use tokio::sync::RwLock;
 use zcash_primitives::{
     block::BlockHash,
     constants::SPENDING_KEY_GENERATOR,
+    keys::OutgoingViewingKey,
     memo::Memo,
     merkle_tree::{CommitmentTree, Hashable, IncrementalWitness, MerklePath},
     note_encryption::SaplingNoteEncryption,
@@ -187,11 +188,13 @@ impl FakeCompactBlockList {
         }
     }
 
-    // Add a new tx into the block, paying the given address the amount.
-    // Returns the nullifier of the new note.
-    pub fn add_tx_paying(&mut self, extfvk: &ExtendedFullViewingKey, value: u64) -> (Nullifier, Transaction, u64) {
-        let to = extfvk.default_address().unwrap().1;
-
+    // Create a dummy compact output with given value sending it to 'to', and encode
+    // the output with the ovk if available
+    fn create_sapling_output(
+        value: u64,
+        ovk: Option<OutgoingViewingKey>,
+        to: &PaymentAddress,
+    ) -> (CompactTx, Transaction, Note) {
         // Create a fake Note for the account
         let mut rng = OsRng;
         let note = Note {
@@ -200,10 +203,8 @@ impl FakeCompactBlockList {
             value,
             rseed: Rseed::BeforeZip212(jubjub::Fr::random(rng)),
         };
-        let nf = note.nf(&extfvk.fvk.vk, 0);
 
-        let mut encryptor =
-            SaplingNoteEncryption::new(None, note.clone(), to.clone(), Memo::default().into(), &mut rng);
+        let mut encryptor = SaplingNoteEncryption::new(ovk, note.clone(), to.clone(), Memo::default().into(), &mut rng);
 
         let mut rng = OsRng;
         let rcv = jubjub::Fr::random(&mut rng);
@@ -238,16 +239,49 @@ impl FakeCompactBlockList {
         td.shielded_outputs.push(od);
         td.binding_sig = Signature::read(&vec![0u8; 64][..]).ok();
         let tx = td.freeze().unwrap();
-        let height = self.next_height;
-        self.txns.push((tx.clone(), height));
 
         let mut ctx = CompactTx::default();
         ctx.hash = tx.txid().clone().0.to_vec();
         ctx.outputs.push(cout);
 
+        (ctx, tx, note)
+    }
+
+    pub fn add_tx_spending(
+        &mut self,
+        nf: &Nullifier,
+        value: u64,
+        ovk: &OutgoingViewingKey,
+        to: &PaymentAddress,
+    ) -> Transaction {
+        let (mut ctx, tx, _) = Self::create_sapling_output(value, Some(ovk.clone()), to);
+
+        println!("Spending nullifier {}", hex::encode(nf.0));
+        let mut cs = CompactSpend::default();
+        cs.nf = nf.to_vec();
+        ctx.spends.push(cs);
+
+        // We should be adding the nullifier to the full tx (tx.shielded_spends) as well, but we don't use it,
+        // so we pretend it doen't exist :)
+
+        let height = self.next_height;
+        self.txns.push((tx.clone(), height));
+        self.add_empty_block().add_txs(vec![ctx]);
+
+        tx
+    }
+
+    // Add a new tx into the block, paying the given address the amount.
+    // Returns the nullifier of the new note.
+    pub fn add_tx_paying(&mut self, extfvk: &ExtendedFullViewingKey, value: u64) -> (Transaction, u64, Note) {
+        let to = extfvk.default_address().unwrap().1;
+        let (ctx, tx, note) = Self::create_sapling_output(value, None, &to);
+
+        let height = self.next_height;
+        self.txns.push((tx.clone(), height));
         self.add_empty_block().add_txs(vec![ctx]);
 
-        (nf, tx, height)
+        (tx, height, note)
     }
 
     pub fn add_empty_block(&mut self) -> &'_ mut FakeCompactBlock {

lib/src/lightclient/tests.rs

@@ -13,10 +13,14 @@ use tokio::task::JoinHandle;
 use tonic::transport::{Channel, Server};
 use tonic::Request;
 
+use zcash_client_backend::address::RecipientAddress;
+use zcash_primitives::consensus::MAIN_NETWORK;
 use zcash_primitives::memo::Memo;
+use zcash_primitives::merkle_tree::{CommitmentTree, IncrementalWitness};
 use zcash_primitives::note_encryption::SaplingNoteEncryption;
 use zcash_primitives::primitives::{Note, Rseed, ValueCommitment};
 use zcash_primitives::redjubjub::Signature;
+use zcash_primitives::sapling::Node;
 use zcash_primitives::transaction::components::{OutputDescription, GROTH_PROOF_SIZE};
 use zcash_primitives::transaction::TransactionData;
 
@@ -144,7 +148,7 @@ async fn z_incoming_z_outgoing() {
     // 2. Send an incoming tx to fill the wallet
     let extfvk1 = lc.wallet.keys().read().await.get_all_extfvks()[0].clone();
     let value = 100_000;
-    let (_nf, tx, _height) = fcbl.add_tx_paying(&extfvk1, value);
+    let (tx, _height, _) = fcbl.add_tx_paying(&extfvk1, value);
     mine_pending_blocks(&mut fcbl, &data, &lc).await;
 
     assert_eq!(lc.wallet.last_scanned_height().await, 101);
@@ -404,7 +408,7 @@ async fn z_incoming_multiz_outgoing() {
     // 2. Send an incoming tx to fill the wallet
     let extfvk1 = lc.wallet.keys().read().await.get_all_extfvks()[0].clone();
     let value = 100_000;
-    let (_nf, _tx, _height) = fcbl.add_tx_paying(&extfvk1, value);
+    let (_tx, _height, _) = fcbl.add_tx_paying(&extfvk1, value);
     mine_pending_blocks(&mut fcbl, &data, &lc).await;
     mine_random_blocks(&mut fcbl, &data, &lc, 5).await;
 
@@ -443,5 +447,65 @@ async fn z_incoming_multiz_outgoing() {
     h1.await.unwrap();
 }
 
+#[tokio::test]
+async fn z_to_z_scan_together() {
+    // Create an incoming tx, and then send that tx, and scan everything together, to make sure it works.
+    let (data, config, ready_rx, stop_tx, h1) = create_test_server().await;
+
+    ready_rx.await.unwrap();
+
+    let lc = LightClient::test_new(&config, None).await.unwrap();
+    let mut fcbl = FakeCompactBlockList::new(0);
+
+    // 1. Start with 100 blocks that are unmined
+    fcbl.add_blocks(100);
+
+    // 2. Send an incoming tx to fill the wallet
+    let extfvk1 = lc.wallet.keys().read().await.get_all_extfvks()[0].clone();
+    let value = 100_000;
+    let (tx, _height, note) = fcbl.add_tx_paying(&extfvk1, value);
+
+    // Calculate witness so we can get the nullifier without it getting mined
+    let tree = fcbl
+        .blocks
+        .iter()
+        .fold(CommitmentTree::<Node>::empty(), |mut tree, fcb| {
+            for tx in &fcb.block.vtx {
+                for co in &tx.outputs {
+                    tree.append(Node::new(co.cmu().unwrap().into())).unwrap();
+                }
+            }
+
+            tree
+        });
+    let witness = IncrementalWitness::from_tree(&tree);
+    let nf = note.nf(&extfvk1.fvk.vk, witness.position() as u64);
+
+    let pa = if let Some(RecipientAddress::Shielded(pa)) = RecipientAddress::decode(&MAIN_NETWORK, EXT_ZADDR) {
+        pa
+    } else {
+        panic!("Couldn't parse address")
+    };
+    let spent_tx = fcbl.add_tx_spending(&nf, 100, &extfvk1.fvk.ovk, &pa);
+
+    // Mine the blocks and sync the lightwallet
+    mine_pending_blocks(&mut fcbl, &data, &lc).await;
+
+    let list = lc.do_list_transactions(false).await;
+
+    assert_eq!(list[0]["block_height"].as_u64().unwrap(), 101);
+    assert_eq!(list[0]["txid"], tx.txid().to_string());
+
+    assert_eq!(list[1]["block_height"].as_u64().unwrap(), 102);
+    assert_eq!(list[1]["txid"], spent_tx.txid().to_string());
+    assert_eq!(list[1]["amount"].as_i64().unwrap(), -(value as i64));
+    assert_eq!(list[1]["outgoing_metadata"][0]["address"], EXT_ZADDR.to_string());
+    assert_eq!(list[1]["outgoing_metadata"][0]["value"].as_u64().unwrap(), 100);
+
+    // Shutdown everything cleanly
+    stop_tx.send(true).unwrap();
+    h1.await.unwrap();
+}
+
 const EXT_ZADDR: &str = "zs1va5902apnzlhdu0pw9r9q7ca8s4vnsrp2alr6xndt69jnepn2v2qrj9vg3wfcnjyks5pg65g9dc";
 const EXT_ZADDR2: &str = "zs1fxgluwznkzm52ux7jkf4st5znwzqay8zyz4cydnyegt2rh9uhr9458z0nk62fdsssx0cqhy6lyv";