Fixed transaction structure. Remote transactions not apply()ing yet.

side-node/src/websocket/mod.rs

@@ -1,14 +1,17 @@
+use std::io::{self, BufRead};
+
 use bft_crdt_derive::add_crdt_fields;
 use bft_json_crdt::json_crdt::SignedOp;
-use bft_json_crdt::keypair::KeyPair;
+use bft_json_crdt::keypair::{Ed25519KeyPair, KeyPair};
 use bft_json_crdt::{
     json_crdt::{BaseCrdt, CrdtNode, IntoCrdtNode},
-    keypair::{make_keypair, ED25519_PUBLIC_KEY_LENGTH},
+    keypair::make_keypair,
     list_crdt::ListCrdt,
     op::ROOT_ID,
 };
 use serde::{Deserialize, Serialize};
-use tokio::time::{self};
+use serde_json::{json, Value};
+// use tokio::time::{self};
 use websockets::WebSocket;
 
 /// Starts a websocket and periodically sends a BFT-CRDT message to the websocket server
@@ -21,21 +24,16 @@ pub(crate) async fn start() -> Result<(), websockets::WebSocketError> {
     let mut bft_crdt = BaseCrdt::<ListExample>::new(&keys);
     println!("Generated a new CRDT with public key: {}", keys.public());
 
-    // generate a placeholder transaction
-    let transaction = generate_transaction();
-
-    let json = convert_to_json(&transaction).unwrap();
-
-    // next job is to keep adding to this guy
-    let signed_op = bft_crdt.doc.list.insert(ROOT_ID, json.clone()).sign(&keys);
-    println!("SignedOp before send is: {:?}", signed_op);
-
-    let mut interval = every_two_seconds();
+    // let mut interval = every_two_seconds();
     loop {
-        interval.tick().await;
-        println!("Sending: {:?}", signed_op);
-        ws.send_text(serde_json::to_string(&signed_op).unwrap())
-            .await?;
+        let stdin = io::stdin();
+        let mut handle = stdin.lock();
+
+        let mut line = String::new();
+        handle.read_line(&mut line).unwrap();
+
+        println!("You entered: {}", line);
+        let _ = send_a_transaction(line, &mut bft_crdt, &mut ws, &keys).await;
 
         let msg = ws.receive().await?;
         println!("Received: {:?}", msg);
@@ -46,15 +44,15 @@ pub(crate) async fn start() -> Result<(), websockets::WebSocketError> {
         // deserialize the message into a Transaction struct
         let operation: SignedOp = serde_json::from_str(&msg).unwrap();
 
-        // TODO:  bft_crdt.apply() changes in here when we receive socket input from other nodes
         bft_crdt.apply(operation);
+
         println!("New crdt state is: {}", bft_crdt.doc.view())
     }
 }
 
-fn every_two_seconds() -> time::Interval {
-    time::interval(time::Duration::from_secs(2))
-}
+// fn every_two_seconds() -> time::Interval {
+//     time::interval(time::Duration::from_secs(2))
+// }
 
 #[add_crdt_fields]
 #[derive(Clone, CrdtNode, Serialize, Deserialize)]
@@ -71,17 +69,33 @@ struct Transaction {
     amount: f64,
 }
 
-fn generate_transaction() -> Transaction {
-    Transaction {
-        from: "Alice".to_string(),
-        to: "Bob".to_string(),
-        amount: 100.0,
-        path: vec![],
-        id: [0; ED25519_PUBLIC_KEY_LENGTH],
-    }
+fn generate_transaction(from: String) -> Value {
+    json!({
+        "from": from,
+        "to": "Bob",
+        "amount": 100.0
+    })
 }
 
-fn convert_to_json(transaction: &Transaction) -> serde_json::Result<String> {
-    let json = serde_json::to_string(&transaction).unwrap();
-    Ok(json)
+async fn send_a_transaction(
+    input: String,
+    bft_crdt: &mut BaseCrdt<ListExample>,
+    ws: &mut WebSocket,
+    keys: &Ed25519KeyPair,
+) -> Result<(), websockets::WebSocketError> {
+    // generate a placeholder transaction
+    let transaction = generate_transaction(input);
+
+    // next job is to keep adding to this guy
+    let signed_op = bft_crdt
+        .doc
+        .list
+        .insert(ROOT_ID, transaction.clone())
+        .sign(&keys);
+    println!("SignedOp being sent is: {:?}", signed_op);
+
+    println!("Sending: {:?}", signed_op);
+    Ok(ws
+        .send_text(serde_json::to_string(&signed_op).unwrap())
+        .await?)
 }