rename request wire format

quic-forward-proxy/src/inbound/proxy_listener.rs

@@ -133,7 +133,8 @@ impl ProxyListener {
                         let raw_request = recv_stream.read_to_end(10_000_000).await.unwrap();
 
                         let proxy_request =
-                            TpuForwardingRequest::deserialize_from_raw_request(&raw_request);
+                            TpuForwardingRequest::try_deserialize_from_wire_format(&raw_request)
+                                .unwrap();
 
                         trace!("proxy request details: {}", proxy_request);
                         let _tpu_identity = proxy_request.get_identity_tpunode();

quic-forward-proxy/src/proxy_request_format.rs

@@ -47,19 +47,24 @@ impl TpuForwardingRequest {
         }
     }
 
-    pub fn serialize_wire_format(&self) -> Vec<u8> {
+    pub fn try_serialize_wire_format(&self) -> anyhow::Result<Vec<u8>> {
-        bincode::serialize(&self).expect("Expect to serialize transactions")
+        bincode::serialize(&self)
+            .context("serialize proxy request")
+            .map_err(anyhow::Error::from)
     }
 
-    // TODO reame
+    pub fn try_deserialize_from_wire_format(
-    pub fn deserialize_from_raw_request(raw_proxy_request: &[u8]) -> TpuForwardingRequest {
+        raw_proxy_request: &[u8],
-        let request = bincode::deserialize::<TpuForwardingRequest>(raw_proxy_request)
+    ) -> anyhow::Result<TpuForwardingRequest> {
-            .context("deserialize proxy request")
+        let request = bincode::deserialize::<TpuForwardingRequest>(raw_proxy_request);
-            .unwrap();
 
-        assert_eq!(request.format_version, FORMAT_VERSION1);
+        if let Ok(ref req) = request {
+            assert_eq!(req.format_version, FORMAT_VERSION1);
+        }
 
         request
+            .context("deserialize proxy request")
+            .map_err(anyhow::Error::from)
     }
 
     pub fn get_tpu_socket_addr(&self) -> SocketAddr {

quic-forward-proxy/tests/proxy_request_format.rs

@@ -20,12 +20,20 @@ fn roundtrip() {
         Pubkey::from_str("Bm8rtweCQ19ksNebrLY92H7x4bCaeDJSSmEeWqkdCeop").unwrap(),
         vec![tx.into()],
     )
-    .serialize_wire_format();
+    .try_serialize_wire_format()
+    .unwrap();
 
     println!("wire_data: {:02X?}", wire_data);
 
-    let request = TpuForwardingRequest::deserialize_from_raw_request(&wire_data);
+    let request = TpuForwardingRequest::try_deserialize_from_wire_format(&wire_data).unwrap();
 
     assert!(request.get_tpu_socket_addr().is_ipv4());
     assert_eq!(request.get_transactions().len(), 1);
 }
+
+#[test]
+fn deserialize_error() {
+    let value: &[u8] = &[1, 2, 3, 4];
+    let result = TpuForwardingRequest::try_deserialize_from_wire_format(value);
+    assert_eq!(result.unwrap_err().to_string(), "deserialize proxy request");
+}