Protocol

Cargo.lock

@@ -137,6 +137,8 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "axum",
+ "serde",
+ "serde_json",
  "tokio",
 ]
 
@@ -431,6 +433,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"
 dependencies = [
  "serde_core",
+ "serde_derive",
 ]
 
 [[package]]

Cargo.toml

@@ -6,4 +6,6 @@ edition = "2024"
 [dependencies]
 anyhow = "1.0.104"
 axum = { version = "0.8.9", features = ["ws"] }
+serde = { version = "1.0.229", features = ["serde_derive"] }
+serde_json = "1.0.151"
 tokio = { version = "1.53.1", features = ["rt", "rt-multi-thread", "macros", "sync"] }

src/protocol/initialize.rs

@@ -1,7 +1,11 @@
 use axum::extract::ws::WebSocket;
 
+use super::*;
+
 impl super::Client {
     pub async fn initialize(mut socket: WebSocket) -> anyhow::Result<Self> {
+        if let Some(ServerMessage::Initialize()) = Client::read_socket(&mut socket).await? {}
+
         Ok(Self {
             socket,
             meta: super::ClientMeta {},

src/protocol/mod.rs

@@ -1,4 +1,5 @@
-use axum::extract::ws::WebSocket;
+use axum::extract::ws::{Message, Utf8Bytes, WebSocket};
+use serde::{Deserialize, Serialize};
 
 pub mod initialize;
 
@@ -8,15 +9,66 @@ pub struct Client {
     pub pub_key: String,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ClientMeta {}
 
-pub enum ClientMessage {}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum ClientMessage<'a> {
+    Error(&'a str),
+}
 
-pub enum ServerMessage {}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum ServerMessage {
+    Initialize(),
+}
 
 impl Client {
-    pub async fn read_socket(mut socket: WebSocket) -> anyhow::Result<ClientMessage> {
+    pub async fn read_socket(socket: &mut WebSocket) -> anyhow::Result<Option<ServerMessage>> {
-        unimplemented!()
+        match socket.recv().await.transpose()? {
-        // Ok(socket.recv().await?)
+            Some(Message::Text(text)) => {
+                if let Ok(msg) = serde_json::from_str(&text.to_string()) {
+                    Ok(Some(msg))
+                } else {
+                    Client::send_socket(
+                        socket,
+                        ClientMessage::Error("Unable to parse message: {text}"),
+                    )
+                    .await?;
+
+                    Ok(None)
+                }
+            }
+
+            Some(Message::Ping(v)) => {
+                socket.send(Message::Pong(v)).await?;
+
+                Ok(None)
+            }
+
+            Some(_) => Ok(None),
+
+            None => Ok(None),
+        }
+    }
+
+    pub async fn send_socket<'a>(
+        socket: &mut WebSocket,
+        message: ClientMessage<'a>,
+    ) -> anyhow::Result<()> {
+        socket
+            .send(Message::Text(Utf8Bytes::from(serde_json::to_string(
+                &message,
+            )?)))
+            .await?;
+
+        Ok(())
+    }
+
+    pub async fn read(&mut self) -> anyhow::Result<Option<ServerMessage>> {
+        Self::read_socket(&mut self.socket).await
+    }
+
+    pub async fn send<'a>(&mut self, message: ClientMessage<'a>) -> anyhow::Result<()> {
+        Self::send_socket(&mut self.socket, message).await
     }
 }