merge upstream updates

lib/src/lightwallet.rs

@@ -168,6 +168,16 @@ impl LightWallet {
         (extsk, extfvk, address)
     }
 
+    pub fn is_shielded_address(addr: &String, config: &LightClientConfig) -> bool {
+        match address::RecipientAddress::from_str(addr,
+                config.hrp_sapling_address(), 
+                config.base58_pubkey_address(), 
+                config.base58_script_address()) {
+            Some(address::RecipientAddress::Shielded(_)) => true,
+            _ => false,
+        }                                    
+    }
+
     pub fn new(seed_phrase: Option<String>, config: &LightClientConfig, latest_block: u64) -> io::Result<Self> {
         // This is the source entropy that corresponds to the 24-word seed phrase
         let mut seed_bytes = [0u8; 32];
@@ -872,6 +882,32 @@ impl LightWallet {
         }
     }
 
+    // If the last taddress was used, ensure we add the next HD taddress to the wallet. 
+    pub fn ensure_hd_taddresses(&self, address: &String) {
+        let last_address = {
+            self.taddresses.read().unwrap().last().unwrap().clone()
+        };
+        
+        if *last_address == *address {
+            // If the wallet is locked, this is a no-op. That is fine, since we really
+            // need to only add new addresses when restoring a new wallet, when it will not be locked.
+            // Also, if it is locked, the user can't create new addresses anyway. 
+            self.add_taddr();
+        }
+    }
+
+    // If the last zaddress was used, ensure we add the next HD zaddress to the wallet
+    pub fn ensure_hd_zaddresses(&self, address: &String) {
+        let last_address = encode_payment_address(self.config.hrp_sapling_address(), self.zaddress.read().unwrap().last().unwrap());
+        
+        if last_address == *address {
+            // If the wallet is locked, this is a no-op. That is fine, since we really
+            // need to only add new addresses when restoring a new wallet, when it will not be locked.
+            // Also, if it is locked, the user can't create new addresses anyway. 
+            self.add_zaddr();
+        }
+    }
+
     // Scan the full Tx and update memos for incoming shielded transactions.
     pub fn scan_full_tx(&self, tx: &Transaction, height: i32, datetime: u64) {
         let mut total_transparent_spend: u64 = 0;
@@ -927,6 +963,9 @@ impl LightWallet {
                         if address == hash.to_base58check(&self.config.base58_pubkey_address(), &[]) {
                             // This is our address. Add this as an output to the txid
                             self.add_toutput_to_wtx(height, datetime, &tx.txid(), &vout, n as u64);
+
+                            // Ensure that we add any new HD addresses
+                            self.ensure_hd_taddresses(&address);
                         }
                     },
                     _ => {}
@@ -1296,9 +1335,15 @@ impl LightWallet {
             // Save notes.
             for output in tx.shielded_outputs
             {
-                info!("Received sapling output");
-
                 let new_note = SaplingNoteData::new(&self.extfvks.read().unwrap()[output.account], output);
+                match LightWallet::note_address(self.config.hrp_sapling_address(), &new_note) {
+                    Some(a) => {
+                        info!("Received sapling output to {}", a);
+                        self.ensure_hd_zaddresses(&a);
+                    },
+                    None => {}
+                }
+
                 match tx_entry.notes.iter().find(|nd| nd.nullifier == new_note.nullifier) {
                     None => tx_entry.notes.push(new_note),
                     Some(_) => warn!("Tried to insert duplicate note for Tx {}", tx.txid)
@@ -1574,7 +1619,14 @@ impl LightWallet {
                             value: *amt,
                             memo: match maybe_memo {
                                 None    => Memo::default(),
-                                Some(s) => Memo::from_str(&s).unwrap(),
+                                Some(s) => {
+                                    // If the address is not a z-address, then drop the memo
+                                    if LightWallet::is_shielded_address(&addr.to_string(), &self.config) {
+                                            Memo::from_str(s).unwrap()
+                                    } else {
+                                        Memo::default()
+                                    }                                        
+                                }
                             },
                         }
                     }).collect::<Vec<_>>();