From efbc822be67f7decb1c09ca8094d2df64c192fd3 Mon Sep 17 00:00:00 2001
From: onyinyang <onyinyang@torproject.org>
Date: Mon, 30 Jan 2023 16:03:12 -0500
Subject: [PATCH] Fix serialization of request/state

---
 crates/lox-wasm/src/lib.rs | 66 +++++++++++++-------------------------
 1 file changed, 22 insertions(+), 44 deletions(-)

diff --git a/crates/lox-wasm/src/lib.rs b/crates/lox-wasm/src/lib.rs
index 6d821ff..6233666 100644
--- a/crates/lox-wasm/src/lib.rs
+++ b/crates/lox-wasm/src/lib.rs
@@ -8,10 +8,16 @@ use std::array::TryFromSliceError;
 use std::panic;
 use wasm_bindgen::prelude::*;
 
-#[derive(Debug,Deserialize, Serialize)]
+#[derive(Deserialize, Serialize)]
 struct ReqState {
-    request: String,
-    state: String,
+    request: lox::proto::open_invite::Request,
+    state: lox::proto::open_invite::State,
+}
+
+#[derive(Debug,Deserialize, Serialize)]
+struct Credential {
+    lox_credential: String,
+    bridgeline: String,
 }
 
 #[wasm_bindgen]
@@ -36,9 +42,9 @@ pub fn open_invite(invite: &[u8]) -> Result<String, JsValue> {
     };
     let (request, state) = open_invite::request(&token);
     let req_state = ReqState {
-        request: serde_json::to_string(&request).unwrap(),
-        state: serde_json::to_string(&state).unwrap(),
-    };
+        request: request,
+        state: state,
+        };
     unsafe {
         log(&format!(
             "Formatted open invite request: {}",
@@ -48,59 +54,31 @@ pub fn open_invite(invite: &[u8]) -> Result<String, JsValue> {
     Ok(serde_json::to_string(&req_state).unwrap())
 }
 
-fn concat_string(request: String, state: String) -> String {
-    let mut new_string: String = "Request:".to_owned();
-    new_string.push_str(&request);
-    new_string.push_str(", State:");
-    new_string.push_str(&state);
-    return new_string;
-}
-
-fn deconcat_string(concatString: String) -> (String, String) {
-
-    ("hello".to_owned(), "world".to_owned())
-
-}
-
 
 #[wasm_bindgen]
 pub fn handle_new_lox_credential(open_lox_result: String, open_lox_response: String, lox_pub: String) -> Result<String, JsValue> {
     unsafe {
     log(&format!("Using server response: {:?}", open_lox_result));
     }
-    let (state, response) = deconcat_string(open_lox_result);
-    let deserialized_state = serde_json::from_str(&state).unwrap();
-    let deserialized_response = serde_json::from_str(&response).unwrap();
+    let req_state: ReqState = serde_json::from_str(&open_lox_result).unwrap();
+    let deserialized_state = req_state.state;
+    let deserialized_response = serde_json::from_str(&open_lox_response).unwrap();
     let deserialized_pubkey = serde_json::from_str(&lox_pub).unwrap();
     let lox_cred = match open_invite::handle_response(deserialized_state, deserialized_response, &deserialized_pubkey) {
         Ok(lox_cred) => lox_cred,
         Err(e) => return Err(JsValue::from(e.to_string())),
     };
-    let serialized_credential = serde_json::to_string(&lox_cred.0).unwrap();
-    let serialized_bridgeline= serde_json::to_string(&lox_cred.1).unwrap();
+    let lox_cred = Credential {
+        lox_credential: serde_json::to_string(&lox_cred.0).unwrap(),
+        bridgeline: serde_json::to_string(&lox_cred.1).unwrap(),
+    };
     unsafe {
-        log(&format!("Got new Lox Credential: {}", serialized_credential));
-        log(&format!("Got new bridgeline: {}", serialized_bridgeline));
+        log(&format!("Got new Lox Credential: {}", lox_cred.lox_credential));
+        log(&format!("Got new bridgeline: {}", lox_cred.bridgeline));
     }
-    let open_lox_response = concat_string(serialized_credential, serialized_bridgeline);
-    Ok(open_lox_response)
+    Ok(serde_json::to_string(&lox_cred).unwrap())
 }
 
-/* Somehow get pubkeys and return to function
-#[wasm_bindgen]
-pub async fn get_pubkey(key_type: String) -> Result<JsValue, JsValue> {
-    let mut url = "http://localhost:8001/".to_owned() + &key_type;
-    let res = reqwest::Client::new()
-        .get(url)
-        .send()
-        .await?;
-
-    let text = res.text().await?;
-    let pub_key: IssuerPubKey = serde_json::from_str(&text).unwrap();
-
-    Ok(pub_key)
-} */
-
 // This should also check the pubkey
 fn validate(invite: &[u8]) -> Result<[u8; OPENINV_LENGTH], TryFromSliceError> {
     invite.try_into()