Merge pull request #74 from chainbound/fix/lz4-compression-test

fix: Lz4 compression with prepended data size, added blob tx de/compression test

msg-transport/src/quic/mod.rs

@@ -1,5 +1,4 @@
 use futures::future::BoxFuture;
-use quinn::{self, Endpoint};
 use std::{
     io,
     net::{SocketAddr, UdpSocket},
@@ -69,7 +68,7 @@ impl Quic {
         &self,
         addr: Option<SocketAddr>,
         server_config: Option<quinn::ServerConfig>,
-    ) -> Result<Endpoint, Error> {
+    ) -> Result<quinn::Endpoint, Error> {
         let socket = UdpSocket::bind(addr.unwrap_or(SocketAddr::from(([0, 0, 0, 0], 0))))?;
 
         let endpoint = quinn::Endpoint::new(
@@ -99,7 +98,7 @@ impl Transport for Quic {
 
     /// Binds a QUIC endpoint to the given address.
     async fn bind(&mut self, addr: SocketAddr) -> Result<(), Self::Error> {
-        let endpoint = Endpoint::server(self.config.server_config.clone(), addr)?;
+        let endpoint = quinn::Endpoint::server(self.config.server_config.clone(), addr)?;
 
         self.endpoint = Some(endpoint);
 

msg-wire/src/compression/lz4.rs

@@ -1,5 +1,5 @@
 use bytes::Bytes;
-use lz4_flex::{compress, decompress};
+use lz4_flex::{compress_prepend_size, decompress_size_prepended};
 use std::io;
 
 use super::{CompressionType, Compressor, Decompressor};
@@ -14,7 +14,7 @@ impl Compressor for Lz4Compressor {
     }
 
     fn compress(&self, data: &[u8]) -> Result<Bytes, io::Error> {
-        let bytes = compress(data);
+        let bytes = compress_prepend_size(data);
 
         Ok(Bytes::from(bytes))
     }
@@ -25,9 +25,7 @@ pub struct Lz4Decompressor;
 
 impl Decompressor for Lz4Decompressor {
     fn decompress(&self, data: &[u8]) -> Result<Bytes, io::Error> {
-        // Usually the Lz4 compression ratio is 2.1x. So 4x should be plenty.
-        let min_uncompressed_size = data.len() * 4;
-        let bytes = decompress(data, min_uncompressed_size).map_err(|e| {
+        let bytes = decompress_size_prepended(data).map_err(|e| {
             io::Error::new(
                 io::ErrorKind::InvalidData,
                 format!("Lz4 decompression failed: {}", e),

msg-wire/src/compression/mod.rs

@@ -160,7 +160,7 @@ mod tests {
     }
 
     #[test]
-    fn test_compare_compression_algorithms() {
+    fn test_compare_compression_algorithms_ssz_block() {
         let data = Bytes::from(
             std::fs::read("../testdata/mainnetCapellaBlock7928030.ssz")
                 .expect("failed to read test file"),
@@ -196,7 +196,62 @@ mod tests {
             lz4_perf, lz4_time
         );
 
-        println!("------");
+        println!("------ SSZ BLOCK -------");
+
+        let gzip = GzipDecompressor;
+        let gzip_time = decompression_test(&gzip_comp, gzip);
+        println!("gzip decompression took {:?}", gzip_time);
+
+        let zstd = ZstdDecompressor;
+        let zstd_time = decompression_test(&zstd_comp, zstd);
+        println!("zstd decompression took {:?}", zstd_time);
+
+        let snappy = SnappyDecompressor;
+        let snappy_time = decompression_test(&snappy_comp, snappy);
+        println!("snappy decompression took {:?}", snappy_time);
+
+        let lz4 = Lz4Decompressor;
+        let lz4_time = decompression_test(&lz4_comp, lz4);
+        println!("lz4 decompression took {:?}", lz4_time);
+    }
+
+    #[test]
+    fn test_compare_compression_algorithms_blob_tx() {
+        let data = Bytes::from(
+            std::fs::read("../testdata/blobTransactionRaw").expect("failed to read test file"),
+        );
+
+        println!("uncompressed data size: {} bytes", data.len());
+
+        let gzip = GzipCompressor::new(6);
+        let (gzip_time, gzip_perf, gzip_comp) = compression_test(&data, gzip);
+        println!(
+            "gzip compression shrank the data by {:.2}% in {:?}",
+            gzip_perf, gzip_time
+        );
+
+        let zstd = ZstdCompressor::new(6);
+        let (zstd_time, zstd_perf, zstd_comp) = compression_test(&data, zstd);
+        println!(
+            "zstd compression shrank the data by {:.2}% in {:?}",
+            zstd_perf, zstd_time
+        );
+
+        let snappy = SnappyCompressor;
+        let (snappy_time, snappy_perf, snappy_comp) = compression_test(&data, snappy);
+        println!(
+            "snappy compression shrank the data by {:.2}% in {:?}",
+            snappy_perf, snappy_time
+        );
+
+        let lz4 = Lz4Compressor;
+        let (lz4_time, lz4_perf, lz4_comp) = compression_test(&data, lz4);
+        println!(
+            "lz4 compression shrank the data by {:.2}% in {:?}",
+            lz4_perf, lz4_time
+        );
+
+        println!("------ BLOB TX ------");
 
         let gzip = GzipDecompressor;
         let gzip_time = decompression_test(&gzip_comp, gzip);