darkirc: Update to new RPC dependencies.

bin/darkirc/Cargo.toml

@@ -31,7 +31,7 @@ url = "2.4.0"
 
 # Encoding and parsing
 bs58 = "0.5.0"
-serde_json = "1.0.105"
+tinyjson= "2.5.1"
 toml = "0.7.6"
 
 # Daemon

bin/darkirc/src/irc/client.rs

@@ -53,7 +53,7 @@ pub struct IrcClient<C: AsyncRead + AsyncWrite + Send + Unpin + 'static> {
     /// Joined channels, mapped here for better SIGHUP UX.
     channels_joined: HashSet<String>,
 
-    server_notifier: smol::channel::Sender<(NotifierMsg, u64)>,
+    server_notifier: smol::channel::Sender<(NotifierMsg, usize)>,
     subscription: Subscription<ClientSubMsg>,
 
     missed_events: Arc<Mutex<Vec<Event<PrivMsgEvent>>>>,
@@ -65,7 +65,7 @@ impl<C: AsyncRead + AsyncWrite + Send + Unpin + 'static> IrcClient<C> {
         read_stream: BufReader<ReadHalf<C>>,
         address: SocketAddr,
         irc_config: IrcConfig,
-        server_notifier: smol::channel::Sender<(NotifierMsg, u64)>,
+        server_notifier: smol::channel::Sender<(NotifierMsg, usize)>,
         subscription: Subscription<ClientSubMsg>,
         missed_events: Arc<Mutex<Vec<Event<PrivMsgEvent>>>>,
     ) -> Self {

bin/darkirc/src/irc/server.rs

@@ -139,7 +139,7 @@ impl IrcServer {
         p2p: P2pPtr,
         model: ModelPtr<PrivMsgEvent>,
         seen: SeenPtr<EventId>,
-        recv: smol::channel::Receiver<(NotifierMsg, u64)>,
+        recv: smol::channel::Receiver<(NotifierMsg, usize)>,
         missed_events: Arc<Mutex<Vec<Event<PrivMsgEvent>>>>,
         clients_subscriptions: SubscriberPtr<ClientSubMsg>,
     ) -> Result<()> {
@@ -199,7 +199,7 @@ impl IrcServer {
     /// Start listening to new connections from irc clients
     pub async fn listen(
         &self,
-        notifier: smol::channel::Sender<(NotifierMsg, u64)>,
+        notifier: smol::channel::Sender<(NotifierMsg, usize)>,
         executor: Arc<smol::Executor<'_>>,
     ) -> Result<()> {
         let (listener, acceptor) = self.setup_listener().await?;
@@ -243,7 +243,7 @@ impl IrcServer {
         &self,
         stream: C,
         peer_addr: SocketAddr,
-        notifier: smol::channel::Sender<(NotifierMsg, u64)>,
+        notifier: smol::channel::Sender<(NotifierMsg, usize)>,
         executor: Arc<smol::Executor<'_>>,
     ) -> Result<()> {
         let (reader, writer) = stream.split();

bin/darkirc/src/main.rs

@@ -16,17 +16,19 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
+use std::collections::HashMap;
+
 use async_std::{
     stream::StreamExt,
     sync::{Arc, Mutex},
     task,
 };
-
 use chrono::{Duration, Utc};
 use irc::ClientSubMsg;
 use log::{debug, info};
 use rand::rngs::OsRng;
 use structopt_toml::StructOptToml;
+use tinyjson::JsonValue;
 
 use darkfi::{
     async_daemonize,
@@ -112,7 +114,11 @@ async fn realmain(settings: Args, executor: Arc<smol::Executor<'_>>) -> Result<(
 
         if settings.output.is_some() {
             let datastore = expand_path(&settings.output.unwrap())?;
-            save_json_file(&datastore, &kp, false)?;
+            let kp_enc = JsonValue::Object(HashMap::from([
+                ("public".to_string(), JsonValue::String(kp.public)),
+                ("secret".to_string(), JsonValue::String(kp.secret)),
+            ]));
+            save_json_file(&datastore, &kp_enc, false)?;
         } else {
             println!("Generated keypair:\n{}", kp);
         }
@@ -129,7 +135,7 @@ async fn realmain(settings: Args, executor: Arc<smol::Executor<'_>>) -> Result<(
 
         if settings.output.is_some() {
             let datastore = expand_path(&settings.output.unwrap())?;
-            save_json_file(&datastore, &pub_encoded, false)?;
+            save_json_file(&datastore, &JsonValue::String(pub_encoded), false)?;
         } else {
             println!("Public key recoverd: {}", pub_encoded);
         }

bin/darkirc/src/rpc.rs

@@ -18,7 +18,7 @@
 
 use async_trait::async_trait;
 use log::debug;
-use serde_json::{json, Value};
+use tinyjson::JsonValue;
 use url::Url;
 
 use darkfi::{
@@ -37,33 +37,17 @@ pub struct JsonRpcInterface {
 #[async_trait]
 impl RequestHandler for JsonRpcInterface {
     async fn handle_request(&self, req: JsonRequest) -> JsonResult {
-        if req.params.as_array().is_none() {
-            return JsonError::new(ErrorCode::InvalidRequest, None, req.id).into()
-        }
-
-        let params = req.params.as_array().unwrap();
-
-        debug!(target: "RPC", "--> {}", serde_json::to_string(&req).unwrap());
+        debug!(target: "darkirc::rpc", "--> {}", req.stringify().unwrap());
 
         match req.method.as_str() {
-            Some("ping") => self.pong(req.id, params).await,
-
-            Some("dnet_switch") => self.dnet_switch(req.id, params).await,
-            Some("dnet_info") => self.dnet_info(req.id, params).await,
-            Some(_) | None => JsonError::new(ErrorCode::MethodNotFound, None, req.id).into(),
+            "ping" => self.pong(req.id, req.params).await,
+            "dnet_switch" => self.dnet_switch(req.id, req.params).await,
+            _ => JsonError::new(ErrorCode::MethodNotFound, None, req.id).into(),
         }
     }
 }
 
 impl JsonRpcInterface {
-    // RPCAPI:
-    // Replies to a ping method.
-    // --> {"jsonrpc": "2.0", "method": "ping", "params": [], "id": 42}
-    // <-- {"jsonrpc": "2.0", "result": "pong", "id": 42}
-    async fn pong(&self, id: Value, _params: &[Value]) -> JsonResult {
-        JsonResponse::new(json!("pong"), id).into()
-    }
-
     // RPCAPI:
     // Activate or deactivate dnet in the P2P stack.
     // By sending `true`, dnet will be activated, and by sending `false` dnet
@@ -71,27 +55,20 @@ impl JsonRpcInterface {
     //
     // --> {"jsonrpc": "2.0", "method": "dnet_switch", "params": [true], "id": 42}
     // <-- {"jsonrpc": "2.0", "result": true, "id": 42}
-    async fn dnet_switch(&self, id: Value, params: &[Value]) -> JsonResult {
-        if params.len() != 1 && params[0].as_bool().is_none() {
+    async fn dnet_switch(&self, id: u16, params: JsonValue) -> JsonResult {
+        let params = params.get::<Vec<JsonValue>>().unwrap();
+        if params.len() != 1 || params[0].is_bool() {
             return JsonError::new(ErrorCode::InvalidParams, None, id).into()
         }
 
-        if params[0].as_bool().unwrap() {
+        let switch = params[0].get::<bool>().unwrap();
+
+        if *switch {
             self.p2p.dnet_enable().await;
         } else {
             self.p2p.dnet_disable().await;
         }
 
-        JsonResponse::new(json!(true), id).into()
-    }
-
-    // RPCAPI:
-    // Retrieves P2P network information.
-    //
-    // --> {"jsonrpc": "2.0", "method": "dnet_info", "params": [], "id": 42}
-    // <-- {"jsonrpc": "2.0", result": {"nodeID": [], "nodeinfo": [], "id": 42}
-    async fn dnet_info(&self, id: Value, _params: &[Value]) -> JsonResult {
-        let dnet_info = self.p2p.dnet_info().await;
-        JsonResponse::new(net::P2p::map_dnet_info(dnet_info), id).into()
+        JsonResponse::new(JsonValue::Boolean(true), id).into()
     }
 }