feat(rpc): add z_validateaddress endpoint

integration-tests/Cargo.toml

@@ -10,6 +10,11 @@ edition = { workspace = true }
 license = { workspace = true }
 version = { workspace = true }
 
+[dependencies]
+zaino-fetch = { workspace = true }
+zaino-testutils = { workspace = true }
+tracing.workspace = true
+
 [dev-dependencies]
 anyhow = { workspace = true }
 
@@ -23,7 +28,7 @@ zaino-state = { workspace = true, features = ["test_dependencies"] }
 zebra-chain.workspace = true
 zebra-state.workspace = true
 zebra-rpc.workspace = true
-zip32 = {workspace = true}
+zip32 = { workspace = true }
 
 core2 = { workspace = true }
 prost = { workspace = true }

integration-tests/src/lib.rs

@@ -1 +1,132 @@
 //! Helpers for integration-tests go here.
+//!
+//! This crate also exposes test-vectors.
+
+pub mod rpc {
+    pub mod json_rpc {
+        pub const VALID_P2PKH_ADDRESS: &str = "tmVqEASZxBNKFTbmASZikGa5fPLkd68iJyx";
+        pub const VALID_P2SH_ADDRESS: &str = "t2MjoXQ2iDrjG9QXNZNCY9io8ecN4FJYK1u";
+
+        pub const VALID_SPROUT_ADDRESS: &str = "ztfhKyLouqi8sSwjRm4YMQdWPjTmrJ4QgtziVQ1Kd1e9EsRHYKofjoJdF438FwcUQnix8yrbSrzPpJJNABewgNffs5d4YZJ";
+        pub const VALID_PAYING_KEY: &str =
+            "c8e8797f1fb5e9cf6b2d000177c5994119279a2629970a4f669aed1362a4cca5";
+        pub const VALID_TRANSMISSION_KEY: &str =
+            "480f78d61bdd7fc4b4edeef9f6305b29753057ab1008d42ded1a3364dac2d83c";
+
+        pub const VALID_SAPLING_ADDRESS: &str = "zregtestsapling1jalqhycwumq3unfxlzyzcktq3n478n82k2wacvl8gwfxk6ahshkxmtp2034qj28n7gl92ka5wca";
+        pub const VALID_DIVERSIFIER: &str = "977e0b930ee6c11e4d26f8";
+        pub const VALID_DIVERSIFIED_TRANSMISSION_KEY: &str =
+            "553ef2f328096a7c2aac6dec85b76b6b9243e733dc9db2eacce3eb8c60592c88";
+
+        pub const VALID_UNIFIED_ADDRESS: &str = "uregtest1njwg60x0jarhyuuxrcdvw854p68cgdfe85822lmclc7z9vy9xqr7t49n3d97k2dwlee82skwwe0ens0rc06p4vr04tvd3j9ckl3qry83ckay4l4ngdq9atg7vuj9z58tfjs0mnsgyrnprtqfv8almu564z498zy6tp2aa569tk8fyhdazyhytel2m32awe4kuy6qq996um3ljaajj36";
+    }
+
+    pub mod z_validate_address {
+        use std::future::Future;
+
+        use zaino_fetch::jsonrpsee::response::z_validate_address::{
+            KnownZValidateAddress, ValidZValidateAddress, ZValidateAddressResponse,
+        };
+        use zaino_testutils::ValidatorKind;
+
+        use crate::rpc::json_rpc::{
+            VALID_DIVERSIFIED_TRANSMISSION_KEY, VALID_DIVERSIFIER, VALID_P2PKH_ADDRESS,
+            VALID_P2SH_ADDRESS, VALID_SAPLING_ADDRESS, VALID_UNIFIED_ADDRESS,
+        };
+
+        pub fn assert_known_valid_eq(
+            resp: ZValidateAddressResponse,
+            expected: ValidZValidateAddress,
+            label: &str,
+        ) {
+            match resp {
+                ZValidateAddressResponse::Known(KnownZValidateAddress::Valid(actual)) => {
+                    assert_eq!(actual, expected, "mismatch for {label}")
+                }
+                other => panic!(
+                    "Unexpected ZValidateAddressResponse for {label}: {:#?}",
+                    other
+                ),
+            }
+        }
+
+        pub async fn run_z_validate_suite<F, Fut>(rpc_call: &F)
+        where
+            // Any callable that takes an address and returns the response (you can unwrap inside)
+            F: Fn(String) -> Fut,
+            Fut: Future<Output = ZValidateAddressResponse>,
+        {
+            // P2PKH
+            let expected_p2pkh = ValidZValidateAddress::p2pkh(VALID_P2PKH_ADDRESS.to_string());
+            assert_known_valid_eq(
+                rpc_call(VALID_P2PKH_ADDRESS.to_string()).await,
+                expected_p2pkh,
+                "P2PKH",
+            );
+
+            // P2SH
+            let expected_p2sh = ValidZValidateAddress::p2sh(VALID_P2SH_ADDRESS.to_string());
+            assert_known_valid_eq(
+                rpc_call(VALID_P2SH_ADDRESS.to_string()).await,
+                expected_p2sh,
+                "P2SH",
+            );
+
+            // Note: It could be the case that Zaino needs to support Sprout. For now, it's been disabled.
+
+            // let expected_sprout = ZValidateAddress::sprout("ztfhKyLouqi8sSwjRm4YMQdWPjTmrJ4QgtziVQ1Kd1e9EsRHYKofjoJdF438FwcUQnix8yrbSrzPpJJNABewgNffs5d4YZJ".to_string(), "c8e8797f1fb5e9cf6b2d000177c5994119279a2629970a4f669aed1362a4cca5".to_string(), "480f78d61bdd7fc4b4edeef9f6305b29753057ab1008d42ded1a3364dac2d83c".to_string());
+
+            // let fs_sprout = zcashd_subscriber
+            //     .z_validate_address("ztfhKyLouqi8sSwjRm4YMQdWPjTmrJ4QgtziVQ1Kd1e9EsRHYKofjoJdF438FwcUQnix8yrbSrzPpJJNABewgNffs5d4YZJ".to_string())
+            //     .await
+            //     .unwrap();
+
+            // assert_eq!(fs_sprout, expected_sprout);
+
+            // Sapling (differs by validator)
+
+            // Unified (differs by validator)
+            let expected_unified =
+                ValidZValidateAddress::unified(VALID_UNIFIED_ADDRESS.to_string());
+            assert_known_valid_eq(
+                rpc_call(VALID_UNIFIED_ADDRESS.to_string()).await,
+                expected_unified,
+                "Unified",
+            );
+
+            // Invalids
+            let by_len = rpc_call("t1123456789ABCDEFGHJKLMNPQRSTUVWXY".to_string()).await;
+            let all_zeroes = rpc_call("t1000000000000000000000000000000000".to_string()).await;
+            assert_eq!(by_len, ZValidateAddressResponse::invalid());
+            assert_eq!(all_zeroes, ZValidateAddressResponse::invalid());
+        }
+
+        pub async fn run_z_validate_sapling<F, Fut>(rpc_call: &F)
+        where
+            // Any callable that takes an address and returns the response (you can unwrap inside)
+            F: Fn(String) -> Fut,
+            Fut: Future<Output = ZValidateAddressResponse>,
+        {
+            // Sapling (differs by validator)
+            let expected_sapling = ValidZValidateAddress::sapling(
+                VALID_SAPLING_ADDRESS.to_string(),
+                Some(VALID_DIVERSIFIER.to_string()),
+                Some(VALID_DIVERSIFIED_TRANSMISSION_KEY.to_string()),
+            );
+        }
+
+        pub async fn run_z_validate_sapling_legacy<F, Fut>(rpc_call: &F)
+        where
+            // Any callable that takes an address and returns the response (you can unwrap inside)
+            F: Fn(String) -> Fut,
+            Fut: Future<Output = ZValidateAddressResponse>,
+        {
+            // Sapling (differs by validator)
+            let expected_sapling = ValidZValidateAddress::sapling(
+                VALID_SAPLING_ADDRESS.to_string(),
+                None::<String>,
+                None::<String>,
+            );
+        }
+    }
+}

integration-tests/tests/fetch_service.rs

@@ -994,6 +994,44 @@ async fn fetch_service_validate_address<V: ValidatorExt>(validator: &ValidatorKi
     test_manager.close().await;
 }
 
+/// This test only runs validation for regtest addresses.
+/// The following addresses were generated with `zcashd` on regtest:
+///
+/// - P2PKH: `tmVqEASZxBNKFTbmASZikGa5fPLkd68iJyx`
+/// - P2SH: `t2MjoXQ2iDrjG9QXNZNCY9io8ecN4FJYK1u`
+/// - Sprout: `ztfhKyLouqi8sSwjRm4YMQdWPjTmrJ4QgtziVQ1Kd1e9EsRHYKofjoJdF438FwcUQnix8yrbSrzPpJJNABewgNffs5d4YZJ`
+/// - Sapling: `zregtestsapling1jalqhycwumq3unfxlzyzcktq3n478n82k2wacvl8gwfxk6ahshkxmtp2034qj28n7gl92ka5wca`
+/// - unified: `uregtest1njwg60x0jarhyuuxrcdvw854p68cgdfe85822lmclc7z9vy9xqr7t49n3d97k2dwlee82skwwe0ens0rc06p4vr04tvd3j9ckl3qry83ckay4l4ngdq9atg7vuj9z58tfjs0mnsgyrnprtqfv8almu564z498zy6tp2aa569tk8fyhdazyhytel2m32awe4kuy6qq996um3ljaajj36`
+/// - invalid (length shorter than expected by 1 char): `t1123456789ABCDEFGHJKLMNPQRSTUVWXY`
+/// - invalid (all zeroes): `t1000000000000000000000000000000000`
+#[allow(deprecated)]
+async fn fetch_service_z_validate_address(validator: &ValidatorKind) {
+    let mut test_manager = TestManager::<FetchService>::launch(
+        validator,
+        &BackendType::Fetch,
+        None,
+        None,
+        None,
+        true,
+        false,
+        false,
+    )
+    .await
+    .unwrap();
+
+    let fetch_service_subscriber = test_manager.service_subscriber.take().unwrap();
+
+    let rpc_call = |addr: String| {
+        let subscriber = &fetch_service_subscriber;
+        async move { subscriber.z_validate_address(addr).await.unwrap() }
+    };
+
+    integration_tests::rpc::z_validate_address::run_z_validate_suite(&rpc_call).await;
+    integration_tests::rpc::z_validate_address::run_z_validate_sapling_legacy(&rpc_call).await;
+
+    test_manager.close().await;
+}
+
 #[allow(deprecated)]
 async fn fetch_service_get_block_nullifiers<V: ValidatorExt>(validator: &ValidatorKind) {
     let mut test_manager =
@@ -1795,6 +1833,11 @@ mod zcashd {
         pub(crate) async fn validate_address() {
             fetch_service_validate_address::<Zcashd>(&ValidatorKind::Zcashd).await;
         }
+
+        #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+        pub(crate) async fn z_validate_address() {
+            fetch_service_z_validate_address(&ValidatorKind::Zcashd).await;
+        }
     }
 
     mod get {
@@ -2068,6 +2111,11 @@ mod zebrad {
         pub(crate) async fn validate_address() {
             fetch_service_validate_address::<Zebrad>(&ValidatorKind::Zebrad).await;
         }
+
+        #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+        pub(crate) async fn z_validate_address() {
+            fetch_service_z_validate_address(&ValidatorKind::Zebrad).await;
+        }
     }
 
     mod get {

integration-tests/tests/json_server.rs

@@ -899,6 +899,22 @@ mod zcashd {
             validate_address_inner().await;
         }
 
+        #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+        async fn z_validate_address() {
+            let (mut test_manager, _zcashd_service, zcashd_subscriber, _zaino_service, _zaino_sub) =
+                create_test_manager_and_fetch_services(false).await;
+
+            let rpc_call = |addr: String| {
+                let subscriber = &zcashd_subscriber;
+                async move { subscriber.z_validate_address(addr).await.unwrap() }
+            };
+
+            integration_tests::rpc::z_validate_address::run_z_validate_suite(&rpc_call).await;
+            integration_tests::rpc::z_validate_address::run_z_validate_sapling(&rpc_call).await;
+
+            test_manager.close().await;
+        }
+
         #[tokio::test(flavor = "multi_thread")]
         async fn z_get_block() {
             z_get_block_inner().await;

integration-tests/tests/state_service.rs

@@ -1635,9 +1635,58 @@ mod zebra {
             }
         }
 
-        mod z {
-            use zcash_local_net::validator::zebrad::Zebrad;
+        mod validation {
+
+            use zaino_state::ZcashIndexer;
+            use zaino_testutils::ValidatorKind;
+
+            use crate::create_test_manager_and_services;
+
+            #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+            pub(crate) async fn z_validate_address() {
+                // const VALID_P2PKH_ADDRESS: &str = "tmVqEASZxBNKFTbmASZikGa5fPLkd68iJyx";
+                // const VALID_P2SH_ADDRESS: &str = "t2MjoXQ2iDrjG9QXNZNCY9io8ecN4FJYK1u";
+
+                // const VALID_SPROUT_ADDRESS: &str = "ztfhKyLouqi8sSwjRm4YMQdWPjTmrJ4QgtziVQ1Kd1e9EsRHYKofjoJdF438FwcUQnix8yrbSrzPpJJNABewgNffs5d4YZJ";
+                // const VALID_PAYING_KEY: &str = "VALID_SPROUT_ADDRESS";
+                // const VALID_TRANSMISSION_KEY: &str =
+                //     "480f78d61bdd7fc4b4edeef9f6305b29753057ab1008d42ded1a3364dac2d83c";
+
+                // const VALID_SAPLING_ADDRESS: &str = "zregtestsapling1jalqhycwumq3unfxlzyzcktq3n478n82k2wacvl8gwfxk6ahshkxmtp2034qj28n7gl92ka5wca";
+                // const VALID_DIVERSIFIER: &str = "977e0b930ee6c11e4d26f8";
+                // const VALID_DIVERSIFIED_TRANSMISSION_KEY: &str =
+                //     "553ef2f328096a7c2aac6dec85b76b6b9243e733dc9db2eacce3eb8c60592c88";
+
+                // const VALID_UNIFIED_ADDRESS: &str = "uregtest1njwg60x0jarhyuuxrcdvw854p68cgdfe85822lmclc7z9vy9xqr7t49n3d97k2dwlee82skwwe0ens0rc06p4vr04tvd3j9ckl3qry83ckay4l4ngdq9atg7vuj9z58tfjs0mnsgyrnprtqfv8almu564z498zy6tp2aa569tk8fyhdazyhytel2m32awe4kuy6qq996um3ljaajj36";
+
+                let (
+                    mut test_manager,
+                    _fetch_service,
+                    _fetch_service_subscriber,
+                    _state_service,
+                    state_service_subscriber,
+                ) = create_test_manager_and_services(
+                    &ValidatorKind::Zebrad,
+                    None,
+                    true,
+                    true,
+                    None,
+                )
+                .await;
+
+                let rpc_call = |addr: String| {
+                    let subscriber = &state_service_subscriber;
+                    async move { subscriber.z_validate_address(addr).await.unwrap() }
+                };
 
+                integration_tests::rpc::z_validate_address::run_z_validate_suite(&rpc_call).await;
+                integration_tests::rpc::z_validate_address::run_z_validate_sapling(&rpc_call).await;
+
+                test_manager.close().await;
+            }
+        }
+
+        mod z {
             use super::*;
 
             #[tokio::test(flavor = "multi_thread")]

zaino-fetch/src/jsonrpsee/connector.rs

@@ -32,6 +32,7 @@ use crate::jsonrpsee::{
         block_subsidy::GetBlockSubsidy,
         mining_info::GetMiningInfoWire,
         peer_info::GetPeerInfo,
+        z_validate_address::{ZValidateAddressError, ZValidateAddressResponse},
         GetBalanceError, GetBalanceResponse, GetBlockCountResponse, GetBlockError, GetBlockHash,
         GetBlockResponse, GetBlockchainInfoResponse, GetInfoResponse, GetMempoolInfoResponse,
         GetSubtreesError, GetSubtreesResponse, GetTransactionResponse, GetTreestateError,
@@ -652,6 +653,23 @@ impl JsonRpSeeConnector {
         self.send_request("validateaddress", params).await
     }
 
+    /// Return information about the given address.
+    ///
+    /// # Parameters
+    /// - `address`: (string, required) The address to validate.
+    ///
+    /// zcashd reference: [`z_validateaddress`](https://zcash.github.io/rpc/z_validateaddress.html)
+    /// method: post
+    /// tags: util
+    pub async fn z_validate_address(
+        &self,
+        address: String,
+    ) -> Result<ZValidateAddressResponse, RpcRequestError<ZValidateAddressError>> {
+        tracing::debug!("Sending jsonrpsee connecter z_validate_address.");
+        let params = vec![serde_json::to_value(address).map_err(RpcRequestError::JsonRpc)?];
+        self.send_request("z_validateaddress", params).await
+    }
+
     /// Returns all transaction ids in the memory pool, as a JSON array.
     ///
     /// zcashd reference: [`getrawmempool`](https://zcash.github.io/rpc/getrawmempool.html)

zaino-fetch/src/jsonrpsee/response.rs

@@ -10,6 +10,7 @@ pub mod block_subsidy;
 pub mod common;
 pub mod mining_info;
 pub mod peer_info;
+pub mod z_validate_address;
 
 use std::{convert::Infallible, num::ParseIntError};