Apply minor lints and cleanups.

bin/darkfid2/src/proto/protocol_block.rs

@@ -20,6 +20,7 @@ use async_std::sync::Arc;
 use async_trait::async_trait;
 use log::debug;
 use smol::Executor;
+use tinyjson::JsonValue;
 use url::Url;
 
 use darkfi::{
@@ -30,10 +31,11 @@ use darkfi::{
         ProtocolJobsManager, ProtocolJobsManagerPtr,
     },
     rpc::jsonrpc::JsonSubscriber,
+    util::encoding::base64,
     validator::ValidatorPtr,
     Result,
 };
-use darkfi_serial::{SerialDecodable, SerialEncodable};
+use darkfi_serial::{serialize, SerialDecodable, SerialEncodable};
 
 /// Auxiliary [`BlockInfo`] wrapper structure used for messaging.
 #[derive(Clone, Debug, SerialEncodable, SerialDecodable)]
@@ -124,7 +126,8 @@ impl ProtocolBlock {
             match self.validator.write().await.append_block(&block_copy.0).await {
                 Ok(()) => {
                     self.p2p.broadcast_with_exclude(&block_copy, &exclude_list).await;
-                    self.subscriber.notify(&[block_copy]).await;
+                    let encoded_block = JsonValue::String(base64::encode(&serialize(&block_copy)));
+                    self.subscriber.notify(vec![encoded_block]).await;
                 }
                 Err(e) => {
                     debug!(

bin/darkfid2/src/proto/protocol_proposal.rs

@@ -20,6 +20,7 @@ use async_std::sync::Arc;
 use async_trait::async_trait;
 use log::debug;
 use smol::Executor;
+use tinyjson::JsonValue;
 use url::Url;
 
 use darkfi::{
@@ -29,10 +30,11 @@ use darkfi::{
         ProtocolJobsManager, ProtocolJobsManagerPtr,
     },
     rpc::jsonrpc::JsonSubscriber,
+    util::encoding::base64,
     validator::{consensus::Proposal, ValidatorPtr},
     Result,
 };
-use darkfi_serial::{SerialDecodable, SerialEncodable};
+use darkfi_serial::{serialize, SerialDecodable, SerialEncodable};
 
 /// Auxiliary [`Proposal`] wrapper structure used for messaging.
 #[derive(Clone, Debug, SerialEncodable, SerialDecodable)]
@@ -114,7 +116,8 @@ impl ProtocolProposal {
             match self.validator.write().await.consensus.append_proposal(&proposal_copy.0).await {
                 Ok(()) => {
                     self.p2p.broadcast_with_exclude(&proposal_copy, &exclude_list).await;
-                    self.subscriber.notify(&[proposal_copy]).await;
+                    let enc_prop = JsonValue::String(base64::encode(&serialize(&proposal_copy)));
+                    self.subscriber.notify(vec![enc_prop]).await;
                 }
                 Err(e) => {
                     debug!(

bin/darkfid2/src/proto/protocol_tx.rs

@@ -20,6 +20,7 @@ use async_std::sync::Arc;
 use async_trait::async_trait;
 use log::debug;
 use smol::Executor;
+use tinyjson::JsonValue;
 use url::Url;
 
 use darkfi::{
@@ -30,10 +31,11 @@ use darkfi::{
     },
     rpc::jsonrpc::JsonSubscriber,
     tx::Transaction,
+    util::encoding::base64,
     validator::ValidatorPtr,
     Result,
 };
-use darkfi_serial::{SerialDecodable, SerialEncodable};
+use darkfi_serial::{serialize, SerialDecodable, SerialEncodable};
 
 /// Auxiliary [`Transaction`] wrapper structure used for messaging.
 #[derive(Clone, Debug, SerialEncodable, SerialDecodable)]
@@ -110,7 +112,8 @@ impl ProtocolTx {
             match self.validator.write().await.append_tx(&tx_copy.0).await {
                 Ok(()) => {
                     self.p2p.broadcast_with_exclude(&tx_copy, &exclude_list).await;
-                    self.subscriber.notify(&[tx_copy]).await;
+                    let encoded_tx = JsonValue::String(base64::encode(&serialize(&tx_copy)));
+                    self.subscriber.notify(vec![encoded_tx]).await;
                 }
                 Err(e) => {
                     debug!(

bin/darkfid2/src/rpc_blockchain.rs

@@ -54,7 +54,7 @@ impl Darkfid {
             return JsonError::new(InvalidParams, None, id).into()
         }
 
-        let slot = match u64::from_str_radix(params[0].get::<String>().unwrap(), 10) {
+        let slot = match params[0].get::<String>().unwrap().parse::<u64>() {
             Ok(v) => v,
             Err(_) => return JsonError::new(ParseError, None, id).into(),
         };

bin/darkfid2/src/task/sync.rs

@@ -16,8 +16,13 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-use darkfi::{util::async_util::sleep, Result};
+use darkfi::{
+    util::{async_util::sleep, encoding::base64},
+    Result,
+};
+use darkfi_serial::serialize;
 use log::{debug, info, warn};
+use tinyjson::JsonValue;
 
 use crate::{
     proto::{SyncRequest, SyncResponse},
@@ -70,7 +75,8 @@ pub async fn sync_task(node: &Darkfid) -> Result<()> {
 
         // Notify subscriber
         for block in &response.blocks {
-            notif_sub.notify(&[block.clone()]).await;
+            let encoded_block = JsonValue::String(base64::encode(&serialize(block)));
+            notif_sub.notify(vec![encoded_block]).await;
         }
 
         let last_received = node.validator.read().await.blockchain.last()?;

bin/faucetd/src/main.rs

@@ -386,7 +386,7 @@ impl Faucetd {
         }
 
         let pubkey = params[0].get::<String>().unwrap();
-        let pubkey = match PublicKey::from_str(&pubkey) {
+        let pubkey = match PublicKey::from_str(pubkey) {
             Ok(v) => v,
             Err(e) => {
                 error!("challenge(): Failed parsing PublicKey from String: {}", e);

bin/genev/genev-cli/src/rpc.rs

@@ -40,7 +40,7 @@ impl Gen {
     pub async fn add(&self, event: GenEvent) -> Result<()> {
         let event = JsonValue::String(base64::encode(&serialize(&event)));
 
-        let req = JsonRequest::new("add", JsonValue::from(vec![event]));
+        let req = JsonRequest::new("add", vec![event]);
         let rep = self.rpc_client.request(req).await?;
 
         debug!("Got reply: {:?}", rep);
@@ -49,7 +49,7 @@ impl Gen {
 
     /// Get current open tasks ids.
     pub async fn list(&self) -> Result<Vec<Event<GenEvent>>> {
-        let req = JsonRequest::new("list", JsonValue::from(vec![]));
+        let req = JsonRequest::new("list", vec![]);
         let rep = self.rpc_client.request(req).await?;
 
         debug!("reply: {:?}", rep);

bin/genev/genevd/src/rpc.rs

@@ -104,7 +104,7 @@ impl JsonRpcInterface {
         }
 
         let b64 = params[0].get::<String>().unwrap();
-        let dec = base64::decode(&b64).unwrap();
+        let dec = base64::decode(b64).unwrap();
         let genevent: GenEvent = deserialize(&dec).unwrap();
 
         let event = Event {

bin/tau/tau-cli/src/main.rs

@@ -235,9 +235,9 @@ async fn main() -> Result<()> {
                 }
                 let base_task = task_from_cli(values)?;
                 for task in tasks.clone() {
-                    let res = tau.update(task.id.into(), base_task.clone()).await?;
+                    let res = tau.update(task.id, base_task.clone()).await?;
                     if res {
-                        let tsk = tau.get_task_by_id(task.id.into()).await?;
+                        let tsk = tau.get_task_by_id(task.id).await?;
                         print_task_info(tsk)?;
                     }
                 }
@@ -251,7 +251,7 @@ async fn main() -> Result<()> {
                 }
                 let state = State::Start;
                 for task in tasks {
-                    if tau.set_state(task.id.into(), &state).await? {
+                    if tau.set_state(task.id, &state).await? {
                         println!("Started task: {:?}", task.id);
                     }
                 }
@@ -265,7 +265,7 @@ async fn main() -> Result<()> {
                 }
                 let state = State::Open;
                 for task in tasks {
-                    if tau.set_state(task.id.into(), &state).await? {
+                    if tau.set_state(task.id, &state).await? {
                         println!("Opened task: {:?}", task.id);
                     }
                 }
@@ -279,7 +279,7 @@ async fn main() -> Result<()> {
                 }
                 let state = State::Pause;
                 for task in tasks {
-                    if tau.set_state(task.id.into(), &state).await? {
+                    if tau.set_state(task.id, &state).await? {
                         println!("Paused task: {:?}", task.id);
                     }
                 }
@@ -293,7 +293,7 @@ async fn main() -> Result<()> {
                 }
                 let state = State::Stop;
                 for task in tasks {
-                    if tau.set_state(task.id.into(), &state).await? {
+                    if tau.set_state(task.id, &state).await? {
                         println!("Stopped task: {}", task.id);
                     }
                 }
@@ -317,9 +317,9 @@ async fn main() -> Result<()> {
                         exit(1)
                     }
 
-                    let res = tau.set_comment(task.id.into(), comment.unwrap().trim()).await?;
+                    let res = tau.set_comment(task.id, comment.unwrap().trim()).await?;
                     if res {
-                        let tsk = tau.get_task_by_id(task.id.into()).await?;
+                        let tsk = tau.get_task_by_id(task.id).await?;
                         print_task_info(tsk)?;
                     }
                 }
@@ -328,7 +328,7 @@ async fn main() -> Result<()> {
 
             TauSubcommand::Info => {
                 for task in tasks {
-                    let task = tau.get_task_by_id(task.id.into()).await?;
+                    let task = tau.get_task_by_id(task.id).await?;
                     print_task_info(task)?;
                 }
                 Ok(())

bin/tau/tau-cli/src/primitives.rs

@@ -34,8 +34,6 @@ pub struct BaseTask {
 
 impl From<BaseTask> for TaskInfo {
     fn from(value: BaseTask) -> Self {
-        let due = if let Some(vd) = value.due { Some(Timestamp(vd)) } else { None };
-
         Self {
             ref_id: String::default(),
             workspace: String::default(),
@@ -46,7 +44,7 @@ impl From<BaseTask> for TaskInfo {
             owner: String::default(),
             assign: value.assign,
             project: value.project,
-            due,
+            due: value.due.map(Timestamp),
             rank: value.rank,
             created_at: Timestamp(u64::default()),
             state: String::default(),

bin/tau/tau-cli/src/rpc.rs

@@ -32,18 +32,13 @@ impl Tau {
 
     /// Add a new task.
     pub async fn add(&self, task: BaseTask) -> Result<u32> {
-        let mut params = vec![];
-        params.push(JsonValue::String(task.title.clone()));
-        params.push(JsonValue::Array(
-            task.tags.iter().map(|x| JsonValue::String(x.clone())).collect(),
-        ));
-        params.push(JsonValue::String(task.desc.unwrap_or("".to_string())));
-        params.push(JsonValue::Array(
-            task.assign.iter().map(|x| JsonValue::String(x.clone())).collect(),
-        ));
-        params.push(JsonValue::Array(
-            task.project.iter().map(|x| JsonValue::String(x.clone())).collect(),
-        ));
+        let mut params = vec![
+            JsonValue::String(task.title.clone()),
+            JsonValue::Array(task.tags.iter().map(|x| JsonValue::String(x.clone())).collect()),
+            JsonValue::String(task.desc.unwrap_or("".to_string())),
+            JsonValue::Array(task.assign.iter().map(|x| JsonValue::String(x.clone())).collect()),
+            JsonValue::Array(task.project.iter().map(|x| JsonValue::String(x.clone())).collect()),
+        ];
 
         let due = if let Some(num) = task.due {
             JsonValue::String(num.to_string())
@@ -80,18 +75,13 @@ impl Tau {
 
     /// Update existing task given it's ID and some params.
     pub async fn update(&self, id: u32, task: BaseTask) -> Result<bool> {
-        let mut params = vec![];
-        params.push(JsonValue::String(task.title.clone()));
-        params.push(JsonValue::Array(
-            task.tags.iter().map(|x| JsonValue::String(x.clone())).collect(),
-        ));
-        params.push(JsonValue::String(task.desc.unwrap_or("".to_string())));
-        params.push(JsonValue::Array(
-            task.assign.iter().map(|x| JsonValue::String(x.clone())).collect(),
-        ));
-        params.push(JsonValue::Array(
-            task.project.iter().map(|x| JsonValue::String(x.clone())).collect(),
-        ));
+        let mut params = vec![
+            JsonValue::String(task.title.clone()),
+            JsonValue::Array(task.tags.iter().map(|x| JsonValue::String(x.clone())).collect()),
+            JsonValue::String(task.desc.unwrap_or("".to_string())),
+            JsonValue::Array(task.assign.iter().map(|x| JsonValue::String(x.clone())).collect()),
+            JsonValue::Array(task.project.iter().map(|x| JsonValue::String(x.clone())).collect()),
+        ];
 
         let due = if let Some(num) = task.due {
             JsonValue::String(num.to_string())

bin/tau/taud/src/jsonrpc.rs

@@ -142,7 +142,7 @@ impl JsonRpcInterface {
 
         let due = match &params[5] {
             JsonValue::Null => None,
-            JsonValue::String(u64_str) => match u64::from_str_radix(&u64_str, 10) {
+            JsonValue::String(u64_str) => match u64_str.parse::<u64>() {
                 Ok(v) => Some(Timestamp(v)),
                 Err(e) => return Err(TaudError::InvalidData(e.to_string())),
             },
@@ -199,8 +199,8 @@ impl JsonRpcInterface {
 
         let mut new_task: TaskInfo = TaskInfo::new(
             self.workspace.lock().await.clone(),
-            &params[0].get::<String>().unwrap(),
-            &params[2].get::<String>().unwrap(),
+            params[0].get::<String>().unwrap(),
+            params[2].get::<String>().unwrap(),
             &self.nickname,
             due,
             rank,
@@ -278,8 +278,8 @@ impl JsonRpcInterface {
             self.load_task_by_id(*params[0].get::<f64>().unwrap() as u32, ws)?;
 
         if states.contains(&state.as_str()) {
-            task.set_state(&state);
-            set_event(&mut task, "state", &self.nickname, &state);
+            task.set_state(state);
+            set_event(&mut task, "state", &self.nickname, state);
         }
 
         self.notify_queue_sender.send(task).await.map_err(Error::from)?;
@@ -305,8 +305,8 @@ impl JsonRpcInterface {
         let ws = self.workspace.lock().await.clone();
         let mut task: TaskInfo = self.load_task_by_id(id, ws)?;
 
-        task.set_comment(Comment::new(&comment_content, &self.nickname));
-        set_event(&mut task, "comment", &self.nickname, &comment_content);
+        task.set_comment(Comment::new(comment_content, &self.nickname));
+        set_event(&mut task, "comment", &self.nickname, comment_content);
 
         self.notify_queue_sender.send(task).await.map_err(Error::from)?;
 
@@ -345,7 +345,7 @@ impl JsonRpcInterface {
         }
 
         let month = match params[0].get::<String>() {
-            Some(u64_str) => match u64::from_str_radix(u64_str, 10) {
+            Some(u64_str) => match u64_str.parse::<u64>() {
                 Ok(v) => Some(Timestamp(v)),
                 //Err(e) => return Err(TaudError::InvalidData(e.to_string())),
                 Err(_) => None,
@@ -496,16 +496,16 @@ impl JsonRpcInterface {
         if fields.contains_key("title") {
             let title = fields["title"].get::<String>().unwrap();
             if !title.is_empty() {
-                task.set_title(&title);
-                set_event(&mut task, "title", &self.nickname, &title);
+                task.set_title(title);
+                set_event(&mut task, "title", &self.nickname, title);
             }
         }
 
         if fields.contains_key("desc") {
             let desc = fields["desc"].get::<String>().unwrap();
             if !desc.is_empty() {
-                task.set_desc(&desc);
-                set_event(&mut task, "desc", &self.nickname, &desc);
+                task.set_desc(desc);
+                set_event(&mut task, "desc", &self.nickname, desc);
             }
         }
 
@@ -538,7 +538,7 @@ impl JsonRpcInterface {
                 match &fields["due"] {
                     JsonValue::Null => None,
                     JsonValue::String(ts_str) => {
-                        Some(Some(Timestamp(u64::from_str_radix(&ts_str, 10).unwrap())))
+                        Some(Some(Timestamp(ts_str.parse::<u64>().unwrap())))
                     }
                     _ => unreachable!(),
                 }

bin/tau/taud/src/month_tasks.rs

@@ -63,7 +63,7 @@ impl From<JsonValue> for MonthTasks {
     fn from(value: JsonValue) -> MonthTasks {
         let created_at = {
             let u64_str = value["created_at"].get::<String>().unwrap();
-            Timestamp(u64::from_str_radix(u64_str, 10).unwrap())
+            Timestamp(u64_str.parse::<u64>().unwrap())
         };
 
         let active_tks: Vec<String> = value["active_tks"]

bin/tau/taud/src/task_info.rs

@@ -136,9 +136,7 @@ impl From<&JsonValue> for TaskEvent {
             action: map["action"].get::<String>().unwrap().clone(),
             author: map["author"].get::<String>().unwrap().clone(),
             content: map["content"].get::<String>().unwrap().clone(),
-            timestamp: Timestamp(
-                u64::from_str_radix(map["timestamp"].get::<String>().unwrap(), 10).unwrap(),
-            ),
+            timestamp: Timestamp(map["timestamp"].get::<String>().unwrap().parse::<u64>().unwrap()),
         }
     }
 }
@@ -172,9 +170,7 @@ impl From<JsonValue> for Comment {
         Comment {
             content: map["content"].get::<String>().unwrap().clone(),
             author: map["author"].get::<String>().unwrap().clone(),
-            timestamp: Timestamp(
-                u64::from_str_radix(map["timestamp"].get::<String>().unwrap(), 10).unwrap(),
-            ),
+            timestamp: Timestamp(map["timestamp"].get::<String>().unwrap().parse::<u64>().unwrap()),
         }
     }
 }
@@ -274,7 +270,7 @@ impl From<JsonValue> for TaskInfo {
                 None
             } else {
                 let u64_str = value["due"].get::<String>().unwrap();
-                Some(Timestamp(u64::from_str_radix(u64_str, 10).unwrap()))
+                Some(Timestamp(u64_str.parse::<u64>().unwrap()))
             }
         };
 
@@ -288,7 +284,7 @@ impl From<JsonValue> for TaskInfo {
 
         let created_at = {
             let u64_str = value["created_at"].get::<String>().unwrap();
-            Timestamp(u64::from_str_radix(u64_str, 10).unwrap())
+            Timestamp(u64_str.parse::<u64>().unwrap())
         };
 
         let events: Vec<TaskEvent> = events.iter().map(|x| x.into()).collect();