Merge pull request #1620 from zancas/make_replyto_orchard_only

Make replyto orchard only

libtonode-tests/tests/concrete.rs

@@ -11,6 +11,7 @@ use zcash_address::unified::Fvk;
 use zcash_client_backend::encoding::encode_payment_address;
 use zcash_primitives::transaction::components::amount::NonNegativeAmount;
 use zcash_primitives::{consensus::BlockHeight, transaction::fees::zip317::MINIMUM_FEE};
+use zingolib::lightclient::describe::UAReceivers;
 use zingolib::testutils::lightclient::from_inputs;
 use zingolib::testutils::{build_fvk_client, increase_height_and_wait_for_client, scenarios};
 use zingolib::utils::conversion::address_from_str;
@@ -1022,7 +1023,7 @@ mod fast {
         for code in ["o", "zo", "z"] {
             recipient.do_new_address(code).await.unwrap();
         }
-        let addresses = recipient.do_addresses(false).await;
+        let addresses = recipient.do_addresses(UAReceivers::All).await;
         let address_5000_nonememo_tuples = addresses
             .members()
             .map(|ua| (ua["address"].as_str().unwrap(), 5_000, None))
@@ -1085,7 +1086,7 @@ mod fast {
 
         //Verify that 1 increment of diversification with a tz receiver set produces uregtest1m8un60u... UA
         let new_address = recipient1.do_new_address("tzo").await.unwrap();
-        let ua_index_1 = recipient1.do_addresses(false).await[1].clone();
+        let ua_index_1 = recipient1.do_addresses(UAReceivers::All).await[1].clone();
         let ua_address_index_1 = ua_index_1["address"].clone().to_string();
         assert_eq!(&new_address[0].to_string(), &ua_address_index_1);
         let sapling_index_1 = ua_index_1["receivers"]["sapling"].clone().to_string();
@@ -1718,7 +1719,8 @@ mod slow {
         let list = recipient.do_list_transactions().await;
         assert_eq!(list[0]["block_height"].as_u64().unwrap(), 4);
         assert_eq!(
-            recipient.do_addresses(false).await[0]["receivers"]["transparent"].to_string(),
+            recipient.do_addresses(UAReceivers::All).await[0]["receivers"]["transparent"]
+                .to_string(),
             recipient_taddr
         );
         assert_eq!(list[0]["amount"].as_u64().unwrap(), value);
@@ -1744,22 +1746,15 @@ mod slow {
         let (_regtest_manager, _cph, _faucet, recipient) =
             scenarios::faucet_recipient_default().await;
         // All addresses
-        let all_addresses = recipient.do_addresses(false).await[0].clone();
-        assert_eq!(
-            all_addresses["address"],
-            "uregtest1wdukkmv5p5n824e8ytnc3m6m77v9vwwl7hcpj0wangf6z23f9x0fnaen625dxgn8cgp67vzw6swuar6uwp3nqywfvvkuqrhdjffxjfg644uthqazrtxhrgwac0a6ujzgwp8y9cwthjeayq8r0q6786yugzzyt9vevxn7peujlw8kp3vf6d8p4fvvpd8qd5p7xt2uagelmtf3vl6w3u8"
-        );
+        let all_addresses = recipient.do_addresses(UAReceivers::All).await[0].clone();
         assert_eq!(all_addresses["receivers"].len(), 3usize);
         assert_eq!(
             all_addresses["receivers"]["transparent"],
             "tmFLszfkjgim4zoUMAXpuohnFBAKy99rr2i"
         );
         // Only Shielded
-        let only_shielded_addresses = recipient.do_addresses(true).await[0].clone();
-        assert_eq!(
-            only_shielded_addresses["address"],
-            "uregtest1rm8kx0snrzfxw4z5uz34tdrg0slzu6ct94z479f8u95d3j46m4glj5xugensqwe5ume0zx8h9k0aprepyksffyyu8yd24cnvnmm2qh0sp5u93e4w2rjzpqjwd7fv32yfgql5yuqjs9l2kq60rchev3kv5j5p6u20ndgjmzs94vu50gy7"
-        );
+        let only_shielded_addresses =
+            recipient.do_addresses(UAReceivers::Shielded).await[0].clone();
         assert_eq!(
             only_shielded_addresses["receivers"]["transparent"],
             JsonValue::Null
@@ -1773,6 +1768,35 @@ mod slow {
             only_shielded_addresses["receivers"]["orchard"],
             all_addresses["receivers"]["orchard"],
         );
+        let only_orchard_address = recipient.do_addresses(UAReceivers::Orchard).await[0].clone();
+        assert_eq!(
+            only_orchard_address["receivers"]["transparent"],
+            JsonValue::Null
+        );
+        assert_eq!(
+            only_orchard_address["receivers"]["sapling"],
+            JsonValue::Null
+        );
+
+        // Compare full UAs
+        let all_addresses_ua = all_addresses["address"].clone();
+        assert_eq!(all_addresses_ua.to_string().len(), 220usize);
+        assert_eq!(
+            all_addresses_ua,
+            "uregtest1wdukkmv5p5n824e8ytnc3m6m77v9vwwl7hcpj0wangf6z23f9x0fnaen625dxgn8cgp67vzw6swuar6uwp3nqywfvvkuqrhdjffxjfg644uthqazrtxhrgwac0a6ujzgwp8y9cwthjeayq8r0q6786yugzzyt9vevxn7peujlw8kp3vf6d8p4fvvpd8qd5p7xt2uagelmtf3vl6w3u8"
+        );
+        let only_shielded_addresses_ua = only_shielded_addresses["address"].clone();
+        assert_eq!(only_shielded_addresses_ua.to_string().len(), 185usize);
+        assert_eq!(
+            only_shielded_addresses_ua,
+            "uregtest1rm8kx0snrzfxw4z5uz34tdrg0slzu6ct94z479f8u95d3j46m4glj5xugensqwe5ume0zx8h9k0aprepyksffyyu8yd24cnvnmm2qh0sp5u93e4w2rjzpqjwd7fv32yfgql5yuqjs9l2kq60rchev3kv5j5p6u20ndgjmzs94vu50gy7"
+        );
+        let only_orchard_address_ua = only_orchard_address["address"].clone();
+        assert_eq!(only_orchard_address_ua.to_string().len(), 113usize);
+        assert_eq!(
+            only_orchard_address_ua,
+            "uregtest1ue949txhf9t2z6ldg8wc6s5t439t2hu55yh9l58gc23cmxthths836nxtpyvhpkrftsp2jnnp9eadtqy2nefxn04eyxeu8l0x5kk8ct9"
+        );
     }
 
     #[tokio::test]
@@ -2528,7 +2552,7 @@ mod slow {
 
         // 3. Check the balance is correct, and we received the incoming transaction from ?outside?
         let b = recipient.do_balance().await;
-        let addresses = recipient.do_addresses(false).await;
+        let addresses = recipient.do_addresses(UAReceivers::All).await;
         assert_eq!(b.sapling_balance.unwrap(), value);
         assert_eq!(b.unverified_sapling_balance.unwrap(), 0);
         assert_eq!(b.spendable_sapling_balance.unwrap(), value);
@@ -3167,7 +3191,7 @@ mod slow {
             .await;
         let seed_of_recipient_restored = {
             recipient_restored.do_sync(true).await.unwrap();
-            let restored_addresses = recipient_restored.do_addresses(false).await;
+            let restored_addresses = recipient_restored.do_addresses(UAReceivers::All).await;
             assert_eq!(
                 &restored_addresses[0]["address"],
                 &original_recipient_address

zingolib/src/commands.rs

@@ -723,7 +723,7 @@ impl Command for AddressCommand {
         indoc! {r#"
             List current addresses in the wallet, shielded excludes t-addresses.
             Usage:
-            addresses shielded
+            addresses [shielded|orchard]
 
         "#}
     }
@@ -733,12 +733,24 @@ impl Command for AddressCommand {
     }
 
     fn exec(&self, args: &[&str], lightclient: &LightClient) -> String {
+        use crate::lightclient::describe::UAReceivers;
         match args.len() {
-            0 => RT.block_on(async move { lightclient.do_addresses(false).await.pretty(2) }),
+            0 => RT.block_on(
+                async move { lightclient.do_addresses(UAReceivers::All).await.pretty(2) },
+            ),
             1 => match args[0] {
-                "shielded" => {
-                    RT.block_on(async move { lightclient.do_addresses(true).await.pretty(2) })
-                }
+                "shielded" => RT.block_on(async move {
+                    lightclient
+                        .do_addresses(UAReceivers::Shielded)
+                        .await
+                        .pretty(2)
+                }),
+                "orchard" => RT.block_on(async move {
+                    lightclient
+                        .do_addresses(UAReceivers::Orchard)
+                        .await
+                        .pretty(2)
+                }),
                 _ => self.help().to_string(),
             },
             _ => self.help().to_string(),

zingolib/src/lib.rs

@@ -4,6 +4,7 @@
 //! Zingo backend code base
 //! Use this high level API to do things like submit transactions to the zcash blockchain
 
+pub use lightclient::describe::UAReceivers;
 #[macro_use]
 extern crate rust_embed;
 

zingolib/src/lightclient.rs

@@ -706,7 +706,10 @@ async fn get_recent_median_price_from_gemini() -> Result<f64, PriceFetchError> {
 
 #[cfg(test)]
 mod tests {
-    use crate::config::{ChainType, RegtestNetwork, ZingoConfig};
+    use crate::{
+        config::{ChainType, RegtestNetwork, ZingoConfig},
+        lightclient::describe::UAReceivers,
+    };
     use testvectors::seeds::CHIMNEY_BETTER_SEED;
     use tokio::runtime::Runtime;
 
@@ -755,7 +758,7 @@ mod tests {
 
         // The first t address and z address should be derived
         Runtime::new().unwrap().block_on(async move {
-            let addresses = lc.do_addresses(false).await;
+            let addresses = lc.do_addresses(UAReceivers::All).await;
             assert_eq!(
                 "zregtestsapling1etnl5s47cqves0g5hk2dx5824rme4xv4aeauwzp4d6ys3qxykt5sw5rnaqh9syxry8vgxr7x3x4"
                     .to_string(),

zingolib/src/lightclient/describe.rs

@@ -39,6 +39,11 @@ pub enum ValueTransferRecordingError {
 fn some_sum(a: Option<u64>, b: Option<u64>) -> Option<u64> {
     a.xor(b).or_else(|| a.zip(b).map(|(v, u)| v + u))
 }
+pub enum UAReceivers {
+    Orchard,
+    Shielded,
+    All,
+}
 impl LightClient {
     /// Uses a query to select all notes across all transactions with specific properties and sum them
     pub async fn query_sum_value(&self, include_notes: OutputQuery) -> u64 {
@@ -53,18 +58,23 @@ impl LightClient {
 
     /// TODO: Add Doc Comment Here!
     // todo use helpers
-    pub async fn do_addresses(&self, shielded_only: bool) -> JsonValue {
+    pub async fn do_addresses(&self, subset: UAReceivers) -> JsonValue {
         let mut objectified_addresses = Vec::new();
         for address in self.wallet.wallet_capability().addresses().iter() {
-            let local_address = if shielded_only {
-                zcash_keys::address::UnifiedAddress::from_receivers(
+            let local_address = match subset {
+                UAReceivers::Orchard => zcash_keys::address::UnifiedAddress::from_receivers(
+                    address.orchard().copied(),
+                    None,
+                    None,
+                )
+                .expect("To create a new address."),
+                UAReceivers::Shielded => zcash_keys::address::UnifiedAddress::from_receivers(
                     address.orchard().copied(),
                     address.sapling().copied(),
                     None,
                 )
-                .expect("To create a new address.")
-            } else {
-                address.clone()
+                .expect("To create a new address."),
+                UAReceivers::All => address.clone(),
             };
             let encoded_ua = local_address.encode(&self.config.chain);
             let transparent = local_address

zingolib/src/testutils.rs

@@ -6,6 +6,7 @@
 pub mod interrupts;
 pub mod scenarios;
 
+use crate::lightclient::describe::UAReceivers;
 use crate::wallet::data::summaries::{
     OrchardNoteSummary, SaplingNoteSummary, SpendSummary, TransactionSummary,
     TransactionSummaryInterface as _, TransparentCoinSummary,
@@ -250,7 +251,7 @@ pub async fn send_value_between_clients_and_sync(
 ) -> Result<String, String> {
     debug!(
         "recipient address is: {}",
-        &recipient.do_addresses(false).await[0]["address"]
+        &recipient.do_addresses(UAReceivers::All).await[0]["address"]
     );
     let txid = lightclient::from_inputs::quick_send(
         sender,

zingolib/src/testutils/lightclient.rs

@@ -1,6 +1,9 @@
 //! This mod is mostly to take inputs, raw data amd convert it into lightclient actions
 //! (obviously) in a test environment.
-use crate::{error::ZingoLibError, lightclient::LightClient};
+use crate::{
+    error::ZingoLibError,
+    lightclient::{describe::UAReceivers, LightClient},
+};
 use zcash_client_backend::{PoolType, ShieldedProtocol};
 use zcash_primitives::transaction::TxId;
 
@@ -18,17 +21,20 @@ pub async fn new_client_from_save_buffer(
 /// calling \[0] on json may panic? not sure -fv
 pub async fn get_base_address(client: &LightClient, pooltype: PoolType) -> String {
     match pooltype {
-        PoolType::Transparent => client.do_addresses(false).await[0]["receivers"]["transparent"]
+        PoolType::Transparent => client.do_addresses(UAReceivers::All).await[0]["receivers"]
+            ["transparent"]
             .clone()
             .to_string(),
-        PoolType::Shielded(ShieldedProtocol::Sapling) => client.do_addresses(false).await[0]
-            ["receivers"]["sapling"]
-            .clone()
-            .to_string(),
-        PoolType::Shielded(ShieldedProtocol::Orchard) => client.do_addresses(false).await[0]
-            ["address"]
-            .take()
-            .to_string(),
+        PoolType::Shielded(ShieldedProtocol::Sapling) => {
+            client.do_addresses(UAReceivers::All).await[0]["receivers"]["sapling"]
+                .clone()
+                .to_string()
+        }
+        PoolType::Shielded(ShieldedProtocol::Orchard) => {
+            client.do_addresses(UAReceivers::All).await[0]["address"]
+                .take()
+                .to_string()
+        }
     }
 }
 /// Get the total fees paid by a given client (assumes 1 capability per client).

zingolib/src/testutils/macros.rs

@@ -5,13 +5,15 @@
 macro_rules! get_base_address_macro {
     ($client:expr, $address_protocol:expr) => {
         match $address_protocol {
-            "unified" => $client.do_addresses(false).await[0]["address"]
+            "unified" => $client.do_addresses($crate::UAReceivers::All).await[0]["address"]
                 .take()
                 .to_string(),
-            "sapling" => $client.do_addresses(false).await[0]["receivers"]["sapling"]
+            "sapling" => $client.do_addresses($crate::UAReceivers::All).await[0]["receivers"]
+                ["sapling"]
                 .clone()
                 .to_string(),
-            "transparent" => $client.do_addresses(false).await[0]["receivers"]["transparent"]
+            "transparent" => $client.do_addresses($crate::UAReceivers::All).await[0]["receivers"]
+                ["transparent"]
                 .clone()
                 .to_string(),
             _ => "ERROR".to_string(),