node, chain: Use features pattern for RPC compression configuration

Author: DaMandal0rian

Cargo.lock

@@ -14,7 +14,7 @@ mod transport;
 pub use self::capabilities::NodeCapabilities;
 pub use self::ethereum_adapter::EthereumAdapter;
 pub use self::runtime::RuntimeAdapter;
-pub use self::transport::Transport;
+pub use self::transport::{Compression, Transport};
 pub use env::ENV_VARS;
 
 pub use buffered_call_cache::BufferedCallCache;

chain/ethereum/src/lib.rs

@@ -314,7 +314,7 @@ mod tests {
     use graph::components::network_provider::ProviderManager;
     use graph::components::network_provider::ProviderName;
     use graph::data::value::Word;
-    use graph::endpoint::Compression;
+
     use graph::http::HeaderMap;
     use graph::{
         endpoint::EndpointMetrics,
@@ -325,7 +325,9 @@ mod tests {
     };
     use std::sync::Arc;
 
-    use crate::{EthereumAdapter, EthereumAdapterTrait, ProviderEthRpcMetrics, Transport};
+    use crate::{
+        Compression, EthereumAdapter, EthereumAdapterTrait, ProviderEthRpcMetrics, Transport,
+    };
 
     use super::{EthereumNetworkAdapter, EthereumNetworkAdapters, NodeCapabilities};
 

chain/ethereum/src/network.rs

@@ -11,6 +11,27 @@ use alloy::transports::{TransportError, TransportFut};
 
 use graph::prelude::alloy::transports::{http::Http, ipc::IpcConnect, ws::WsConnect};
 
+/// Compression method for RPC requests.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum Compression {
+    #[default]
+    None,
+    Gzip,
+    Brotli,
+    Deflate,
+}
+
+impl std::fmt::Display for Compression {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Compression::None => write!(f, "none"),
+            Compression::Gzip => write!(f, "gzip"),
+            Compression::Brotli => write!(f, "brotli"),
+            Compression::Deflate => write!(f, "deflate"),
+        }
+    }
+}
+
 /// Abstraction over different transport types for Alloy providers.
 #[derive(Clone, Debug)]
 pub enum Transport {
@@ -46,17 +67,24 @@ impl Transport {
         headers: graph::http::HeaderMap,
         metrics: Arc<EndpointMetrics>,
         provider: impl AsRef<str>,
-        gzip: bool,
+        compression: Compression,
     ) -> Self {
         let mut client_builder = reqwest::Client::builder().default_headers(headers);
 
-        if gzip {
-            client_builder = client_builder.gzip(true);
+        match compression {
+            Compression::None => {}
+            Compression::Gzip => {
+                client_builder = client_builder.gzip(true);
+            }
+            Compression::Brotli => {
+                client_builder = client_builder.brotli(true);
+            }
+            Compression::Deflate => {
+                client_builder = client_builder.deflate(true);
+            }
         }
 
-        let client = client_builder
-            .build()
-            .expect("Failed to build HTTP client");
+        let client = client_builder.build().expect("Failed to build HTTP client");
 
         let http_transport = Http::with_client(client, rpc);
         let metrics_transport = MetricsHttp::new(http_transport, metrics, provider.as_ref().into());

chain/ethereum/src/transport.rs

@@ -27,7 +27,7 @@ chrono = "0.4.43"
 envconfig = { workspace = true }
 Inflector = "0.11.3"
 atty = "0.2"
-reqwest = { version = "0.12.23", features = ["json", "stream", "multipart", "gzip"] }
+reqwest = { version = "0.12.23", features = ["json", "stream", "multipart", "gzip", "brotli", "deflate"] }
 ethabi = "17.2"
 hex = "0.4.3"
 http0 = { version = "0", package = "http" }

graph/Cargo.toml

@@ -7,7 +7,6 @@ use std::{
 };
 
 use prometheus::IntCounterVec;
-use serde::{Deserialize, Serialize};
 use slog::{warn, Logger};
 
 use crate::components::network_provider::ProviderName;
@@ -18,26 +17,6 @@ use crate::{components::metrics::MetricsRegistry, data::value::Word};
 /// avoid locking since we don't need to modify the entire struture.
 type ProviderCount = Arc<HashMap<ProviderName, AtomicU64>>;
 
-/// Compression methods for RPC transports
-#[derive(Copy, Clone, Debug, Deserialize, Serialize, PartialEq)]
-pub enum Compression {
-    #[serde(rename = "none")]
-    None,
-    #[serde(rename = "gzip")]
-    Gzip,
-    // Future compression methods can be added here:
-    // #[serde(rename = "brotli")]
-    // Brotli,
-    // #[serde(rename = "deflate")]
-    // Deflate,
-}
-
-impl Default for Compression {
-    fn default() -> Self {
-        Compression::None
-    }
-}
-
 /// This struct represents all the current labels except for the result
 /// which is added separately. If any new labels are necessary they should
 /// remain in the same order as added in [`EndpointMetrics::new`]

graph/src/endpoint.rs

@@ -48,7 +48,7 @@ shard = "primary"
 provider = [
   { label = "mainnet-0", url = "http://rpc.mainnet.io", features = ["archive", "traces"] },
   { label = "mainnet-1", details = { type = "web3call", url = "http://rpc.mainnet.io", features = ["archive", "traces"] }},
-  { label = "mainnet-2", details = { type = "web3", url = "http://rpc.mainnet.io", features = ["archive"], compression = "gzip" }},
+  { label = "mainnet-2", details = { type = "web3", url = "http://rpc.mainnet.io", features = ["archive", "compression/gzip"] }},
   { label = "firehose", details = { type = "firehose", url = "http://localhost:9000", features = [] }},
 ]
 

node/resources/tests/full_config.toml

@@ -206,12 +206,13 @@ pub async fn create_ethereum_networks_for_chain(
         }
 
         let logger = logger.new(o!("provider" => provider.label.clone()));
+        let compression = web3.compression();
         info!(
             logger,
             "Creating transport";
             "url" => &web3.url,
             "capabilities" => capabilities,
-            "compression" => ?web3.compression
+            "compression" => compression.to_string()
         );
 
         use crate::config::Transport::*;
@@ -222,7 +223,7 @@ pub async fn create_ethereum_networks_for_chain(
                 web3.headers.clone(),
                 endpoint_metrics.cheap_clone(),
                 &provider.label,
-                web3.compression,
+                compression,
             ),
             Ipc => Transport::new_ipc(&web3.url).await,
             Ws => Transport::new_ws(&web3.url).await,