Add jsonrpc

Cargo.toml

@@ -21,11 +21,14 @@ nym-bin-common = { git = "https://github.com/nymtech/nym", branch = "master" }
 nym-sphinx-anonymous-replies = { git = "https://github.com/nymtech/nym", branch = "master" }
 
 http = "0.2.4"
-tokio = { version = "1", features = ["full"] }
+tokio = { version = "1.37.0", features = ["full"] }
 tonic = "0.10.2"
 prost = "0.12"
 bytes = "1.1"
 http-body = "0.4.4"
-
-
+hyper = { version = "0.14.28", features = ["full"] }
+hyper-rustls = { version = "0.23", features = ["http2"] }
+tower = { version = "0.4.13" }
+tokio-rustls = "0.23"
+rustls-pemfile = "1.0.0"
 

integration-tests/Cargo.toml

@@ -33,5 +33,5 @@ shardtree = "0.3"
 json = "0.12.4"
 log = "0.4.17"
 itertools = "0.10.5"
-serde_json = "1.0.107"
+serde_json = "1.0.117"
 hex = "0.4"

integration-tests/tests/integrations.rs

@@ -8,32 +8,32 @@ use zingoproxy_testutils::{drop_test_manager, TestManager};
 
 use zingo_netutils::GrpcConnector;
 
-mod proxy {
+mod wallet {
     use super::*;
 
     #[tokio::test]
-    async fn connect_to_lwd_get_info() {
+    async fn connect_to_node_get_info() {
         let online = Arc::new(AtomicBool::new(true));
         let (test_manager, regtest_handler, _proxy_handler) =
             TestManager::launch(online.clone()).await;
 
         println!(
-            "Attempting to connect to GRPC server at URI: {}",
+            "@zingoproxytest: Attempting to connect to GRPC server at URI: {}.",
             test_manager.get_proxy_uri()
         );
-
         let mut client = GrpcConnector::new(test_manager.get_proxy_uri())
             .get_client()
             .await
             .expect("Failed to create GRPC client");
-
         let lightd_info = client
             .get_lightd_info(zcash_client_backend::proto::service::Empty {})
             .await
             .expect("Failed to retrieve lightd info from GRPC server");
 
-        println!("{:#?}", lightd_info.into_inner());
-
+        println!(
+            "@zingoproxytest: Lightd_info response:\n{:#?}.",
+            lightd_info.into_inner()
+        );
         drop_test_manager(
             Some(test_manager.temp_conf_dir.path().to_path_buf()),
             regtest_handler,
@@ -43,7 +43,7 @@ mod proxy {
     }
 
     #[tokio::test]
-    async fn send_over_proxy() {
+    async fn send_and_sync_shielded() {
         let online = Arc::new(AtomicBool::new(true));
         let (test_manager, regtest_handler, _proxy_handler) =
             TestManager::launch(online.clone()).await;
@@ -52,10 +52,7 @@ mod proxy {
         test_manager.regtest_manager.generate_n_blocks(1).unwrap();
         zingo_client.do_sync(false).await.unwrap();
 
-        println!(
-            "zingo_client balance: {:#?}",
-            zingo_client.do_balance().await
-        );
+        // std::thread::sleep(std::time::Duration::from_secs(10));
 
         zingo_client
             .do_send(vec![(
@@ -65,29 +62,66 @@ mod proxy {
             )])
             .await
             .unwrap();
+        test_manager.regtest_manager.generate_n_blocks(1).unwrap();
         zingo_client.do_sync(false).await.unwrap();
+        let balance = zingo_client.do_balance().await;
+        println!("@zingoproxytest: zingo_client balance: \n{:#?}.", balance);
 
-        println!(
-            "zingo_client balance: {:#?}",
-            zingo_client.do_balance().await
-        );
+        assert_eq!(balance.sapling_balance.unwrap(), 250_000);
+        drop_test_manager(
+            Some(test_manager.temp_conf_dir.path().to_path_buf()),
+            regtest_handler,
+            online,
+        )
+        .await;
+    }
 
-        assert_eq!(
-            zingo_client.do_balance().await.sapling_balance.unwrap(),
-            250_000
-        );
+    #[tokio::test]
+    async fn send_and_sync_transparent() {
+        let online = Arc::new(AtomicBool::new(true));
+        let (test_manager, regtest_handler, _proxy_handler) =
+            TestManager::launch(online.clone()).await;
+        let zingo_client = test_manager.build_lightclient().await;
 
+        test_manager.regtest_manager.generate_n_blocks(1).unwrap();
+        zingo_client.do_sync(false).await.unwrap();
+        zingo_client
+            .do_send(vec![(
+                &zingolib::get_base_address!(zingo_client, "transparent"),
+                250_000,
+                None,
+            )])
+            .await
+            .unwrap();
+        zingo_client
+            .do_send(vec![(
+                &zingolib::get_base_address!(zingo_client, "transparent"),
+                250_000,
+                None,
+            )])
+            .await
+            .unwrap();
+        test_manager.regtest_manager.generate_n_blocks(1).unwrap();
+        zingo_client.do_sync(false).await.unwrap();
+        let balance = zingo_client.do_balance().await;
+        println!("@zingoproxytest: zingo_client balance: \n{:#?}.", balance);
+
+        assert_eq!(balance.transparent_balance.unwrap(), 500_000);
         drop_test_manager(
             Some(test_manager.temp_conf_dir.path().to_path_buf()),
             regtest_handler,
             online,
         )
         .await;
     }
+
+    // TODO: Add test for get_mempool_stream: lightclient::start_mempool_monitor.
+    // #[tokio::test]
+    // async fn mempool_monitor() {}
 }
 
 mod nym {
-    // TODO: Build nym encanhed zingolib version using zingo-rpc::walletrpc::service.
+    // TODO: Build nym enhanced zingolib version using zingo-rpc::walletrpc::service.
 }
 
 mod darkside {

zingo-proxyd/Cargo.toml

@@ -36,14 +36,13 @@ tonic = { workspace = true }
 prost = { workspace = true }
 bytes = { workspace = true }
 http-body = { workspace = true }
-
+tower = { workspace = true }
+hyper-rustls = { workspace = true, features = ["http2"] }
+hyper = { workspace = true, features = ["full"] }
+tokio-rustls = { workspace = true }
+rustls-pemfile = { workspace = true }
 
 tokio-socks = "0.5"
 ctrlc = "3.2.1"
-tower = { version = "0.4" }
-hyper-rustls = { version = "0.23", features = ["http2"] }
-tokio-rustls = "0.23"
-hyper = { version = "0.14", features = ["full"] }
 webpki-roots = "0.21.0"
-rustls-pemfile = "1.0.0"
 

zingo-proxyd/src/bin/zingoproxyd.rs

@@ -14,14 +14,15 @@ async fn main() {
     let online = Arc::new(AtomicBool::new(true));
     let online_ctrlc = online.clone();
     ctrlc::set_handler(move || {
-        println!("Received Ctrl+C, exiting.");
+        println!("@zingoproxyd: Received Ctrl+C, exiting.");
         online_ctrlc.store(false, Ordering::SeqCst);
         process::exit(0);
     })
     .expect("Error setting Ctrl-C handler");
 
     nym_bin_common::logging::setup_logging();
 
+    #[allow(unused_mut)]
     let mut proxy_port: u16 = 8080;
     #[cfg(feature = "nym_poc")]
     {

zingo-proxyd/src/nym_server.rs

@@ -1,4 +1,8 @@
 //! Nym-gRPC server implementation.
+//!
+//! TODO: - Add NymServerError error type and rewrite functions to return <Result<(), NymServerError>>, propagating internal errors. Include NymClientError from zingo-rpc::nym::utils.
+//!       - Update NymServer to handle all service RPCs (currently only accepts send_command). [Return "Not Yet Implemented" for unimplemented RPC's?]
+//!       - Update NymServer to handle multiple requests, from multiple clients, simultaniously. [Combine with zingoproxyd "queue" logic when implemented?]
 
 use std::sync::{
     atomic::{AtomicBool, Ordering},
@@ -46,17 +50,26 @@ impl NymServer {
                     .unwrap();
 
                 //print request for testing
-                println!("request received: {:?}", &request_vu8[..]);
-                println!("request length: {}", &request_vu8[..].len());
+                println!(
+                    "@zingoproxyd[nym]: request received: {:?}",
+                    &request_vu8[..]
+                );
+                println!(
+                    "@zingoproxyd[nym]: request length: {}",
+                    &request_vu8[..].len()
+                );
 
                 let request = RawTransaction::decode(&request_vu8[..]).unwrap();
                 let response = NymClient::nym_send_transaction(&request).await.unwrap();
                 let mut response_vu8 = Vec::new();
                 response.encode(&mut response_vu8).unwrap();
 
                 //print response for testing
-                println!("response sent: {:?}", &response_vu8[..]);
-                println!("response length: {}", &response_vu8[..].len());
+                println!("@zingoproxyd[nym]: response sent: {:?}", &response_vu8[..]);
+                println!(
+                    "@zingoproxyd[nym]: response length: {}",
+                    &response_vu8[..].len()
+                );
 
                 let return_recipient = AnonymousSenderTag::try_from_base58_string(
                     request_in[0].sender_tag.unwrap().to_base58_string(),