feat: compress bulk txns with zlib compression

Author: daniilrrr

metabased-sequencer/interceptor/Cargo.toml

@@ -34,3 +34,9 @@ serde = "1.0.210"
 hyper-util = "0.1.8"
 alloy-primitives = "0.8.7"
 url = { version = "2", features = ["serde"] }
+brotli = "7.0.0"
+rand = "0.8.5"
+flate2 = "1.0.34"
+criterion = "0.5.1"
+hex = "0.4.3"
+prettytable-rs = "0.10.0"

metabased-sequencer/interceptor/src/application/send_raw_transaction.rs

@@ -39,6 +39,7 @@ where
         )?;
     }
 
+    // 3. Submission/forwarding:
     chain.process_transaction(encoded).await?;
 
     Ok(tx.tx_hash().to_owned())

metabased-sequencer/interceptor/src/domain/chain.rs

@@ -9,6 +9,8 @@ pub trait MetabasedSequencerChainService {
     async fn process_transaction(&self, tx: Bytes) -> Result<(), Self::Error>;
 
     async fn process_bulk_transactions(&self, tx: Vec<Bytes>) -> Result<(), Self::Error>;
+    
+    async fn process_bulk_transactions_compressed(&self, tx: Vec<Bytes>) -> Result<(), Self::Error>;
 }
 
 #[cfg(test)]
@@ -20,6 +22,7 @@ mod tests {
     use std::convert::Infallible;
     use std::sync::Arc;
     use tokio::sync::RwLock;
+    use crate::infrastructure::compress_transactions;
 
     #[derive(Debug)]
     pub struct InMemoryMetabasedSequencerChain {
@@ -47,5 +50,12 @@ mod tests {
 
             Ok(())
         }
+        
+        async fn process_bulk_transactions_compressed(&self, tx: Vec<Bytes>) -> Result<(), Infallible> {
+            let compressed_txns = compress_transactions(&tx)?;
+            self.transactions.write().await.push(compressed_txns);
+
+            Ok(())
+        }
     }
 }

metabased-sequencer/interceptor/src/infrastructure/mod.rs

@@ -1,3 +1,5 @@
 mod sol;
+mod zlib_compression;
 
 pub use sol::SolMetabasedSequencerChainService;
+pub use zlib_compression::{compress_transactions};

metabased-sequencer/interceptor/src/infrastructure/sol.rs

@@ -1,12 +1,13 @@
 use crate::domain::primitives::{Address, Bytes};
 use crate::domain::MetabasedSequencerChainService;
-use crate::infrastructure::sol::MetabasedSequencerChain::MetabasedSequencerChainInstance;
 use alloy::network::Network;
 use alloy::providers::Provider;
 use alloy::sol;
 use alloy::transports::Transport;
 use async_trait::async_trait;
 use std::marker::PhantomData;
+use crate::infrastructure::compress_transactions;
+use crate::infrastructure::sol::MetabasedSequencerChain::MetabasedSequencerChainInstance;
 
 sol! {
     #[derive(Debug, PartialEq, Eq)]
@@ -17,6 +18,7 @@ sol! {
         function emitTransactionProcessed(bytes calldata encodedTxn) public;
         function processTransaction(bytes calldata encodedTxn) public;
         function processBulkTransactions(bytes[] calldata encodedTxns) public;
+        function processBulkTransactionsCompressed(bytes calldata compressedTxns) public; // TODO: Contract needs to be updated
     }
 }
 
@@ -52,14 +54,20 @@ impl<P: Provider<T, N>, T: Transport + Clone, N: Network> MetabasedSequencerChai
     type Error = alloy::contract::Error;
 
     async fn process_transaction(&self, tx: Bytes) -> Result<(), Self::Error> {
+        // Do not compress individual transaction, doesn't get smaller
         self.contract().processTransaction(tx).call().await?;
-
         Ok(())
     }
 
     async fn process_bulk_transactions(&self, tx: Vec<Bytes>) -> Result<(), Self::Error> {
         self.contract().processBulkTransactions(tx).call().await?;
+        Ok(())
+    }
 
+    async fn process_bulk_transactions_compressed(&self, tx: Vec<Bytes>) -> Result<(), Self::Error> {
+        // Note: Compression starts being beneficial at ~5 transactions
+        let compressed_txs = compress_transactions(&tx)?;
+        self.contract().processBulkTransactionsCompressed(compressed_txs).call().await?;
         Ok(())
     }
-}
+}