feat(providers): adding dRPC endpoint for Solana (#902)

Author: geekbrother

src/env/drpc.rs

@@ -0,0 +1,47 @@
+use {
+    super::ProviderConfig,
+    crate::providers::{Priority, Weight},
+    std::collections::HashMap,
+};
+
+#[derive(Debug)]
+pub struct DrpcConfig {
+    pub supported_chains: HashMap<String, (String, Weight)>,
+}
+
+impl Default for DrpcConfig {
+    fn default() -> Self {
+        Self {
+            supported_chains: default_supported_chains(),
+        }
+    }
+}
+
+impl ProviderConfig for DrpcConfig {
+    fn supported_chains(self) -> HashMap<String, (String, Weight)> {
+        self.supported_chains
+    }
+
+    fn supported_ws_chains(self) -> HashMap<String, (String, Weight)> {
+        HashMap::new()
+    }
+
+    fn provider_kind(&self) -> crate::providers::ProviderKind {
+        crate::providers::ProviderKind::Drpc
+    }
+}
+
+fn default_supported_chains() -> HashMap<String, (String, Weight)> {
+    // Keep in-sync with SUPPORTED_CHAINS.md
+
+    HashMap::from([
+        // Solana Mainnet
+        (
+            "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp".into(),
+            (
+                "https://solana.drpc.org/".into(),
+                Weight::new(Priority::Normal).unwrap(),
+            ),
+        ),
+    ])
+}

src/env/mod.rs

@@ -14,15 +14,16 @@ use {
     std::{collections::HashMap, fmt::Display},
 };
 pub use {
-    arbitrum::*, aurora::*, base::*, berachain::*, binance::*, dune::*, getblock::*, infura::*,
-    lava::*, mantle::*, morph::*, near::*, pokt::*, publicnode::*, quicknode::*, server::*,
-    solscan::*, unichain::*, wemix::*, zerion::*, zksync::*, zora::*,
+    arbitrum::*, aurora::*, base::*, berachain::*, binance::*, drpc::*, dune::*, getblock::*,
+    infura::*, lava::*, mantle::*, morph::*, near::*, pokt::*, publicnode::*, quicknode::*,
+    server::*, solscan::*, unichain::*, wemix::*, zerion::*, zksync::*, zora::*,
 };
 mod arbitrum;
 mod aurora;
 mod base;
 mod berachain;
 mod binance;
+mod drpc;
 mod dune;
 mod getblock;
 mod infura;

src/lib.rs

@@ -18,20 +18,21 @@ use {
         Router,
     },
     env::{
-        ArbitrumConfig, AuroraConfig, BaseConfig, BerachainConfig, BinanceConfig, DuneConfig,
-        GetBlockConfig, InfuraConfig, LavaConfig, MantleConfig, MorphConfig, NearConfig,
-        PoktConfig, PublicnodeConfig, QuicknodeConfig, SolScanConfig, UnichainConfig, WemixConfig,
-        ZKSyncConfig, ZerionConfig, ZoraConfig,
+        ArbitrumConfig, AuroraConfig, BaseConfig, BerachainConfig, BinanceConfig, DrpcConfig,
+        DuneConfig, GetBlockConfig, InfuraConfig, LavaConfig, MantleConfig, MorphConfig,
+        NearConfig, PoktConfig, PublicnodeConfig, QuicknodeConfig, SolScanConfig, UnichainConfig,
+        WemixConfig, ZKSyncConfig, ZerionConfig, ZoraConfig,
     },
     error::RpcResult,
     http::Request,
     hyper::{header::HeaderName, http, server::conn::AddrIncoming, Body, Server},
     providers::{
         ArbitrumProvider, AuroraProvider, BaseProvider, BerachainProvider, BinanceProvider,
-        DuneProvider, GetBlockProvider, InfuraProvider, InfuraWsProvider, LavaProvider,
-        MantleProvider, MorphProvider, NearProvider, PoktProvider, ProviderRepository,
-        PublicnodeProvider, QuicknodeProvider, SolScanProvider, UnichainProvider, WemixProvider,
-        ZKSyncProvider, ZerionProvider, ZoraProvider, ZoraWsProvider,
+        DrpcProvider, DuneProvider, GetBlockProvider, InfuraProvider, InfuraWsProvider,
+        LavaProvider, MantleProvider, MorphProvider, NearProvider, PoktProvider,
+        ProviderRepository, PublicnodeProvider, QuicknodeProvider, SolScanProvider,
+        UnichainProvider, WemixProvider, ZKSyncProvider, ZerionProvider, ZoraProvider,
+        ZoraWsProvider,
     },
     sqlx::postgres::PgPoolOptions,
     std::{
@@ -512,6 +513,7 @@ fn init_providers(config: &ProvidersConfig) -> ProviderRepository {
         .add_rpc_provider::<LavaProvider, LavaConfig>(LavaConfig::new(config.lava_api_key.clone()));
     providers.add_rpc_provider::<MorphProvider, MorphConfig>(MorphConfig::default());
     providers.add_rpc_provider::<WemixProvider, WemixConfig>(WemixConfig::default());
+    providers.add_rpc_provider::<DrpcProvider, DrpcConfig>(DrpcConfig::default());
 
     if let Some(getblock_access_tokens) = &config.getblock_access_tokens {
         providers.add_rpc_provider::<GetBlockProvider, GetBlockConfig>(GetBlockConfig::new(

src/providers/drpc.rs

@@ -0,0 +1,96 @@
+use {
+    super::{Provider, ProviderKind, RateLimited, RpcProvider, RpcProviderFactory},
+    crate::{
+        env::DrpcConfig,
+        error::{RpcError, RpcResult},
+    },
+    async_trait::async_trait,
+    axum::{
+        http::HeaderValue,
+        response::{IntoResponse, Response},
+    },
+    hyper::{client::HttpConnector, http, Client, Method},
+    hyper_tls::HttpsConnector,
+    std::collections::HashMap,
+    tracing::debug,
+};
+
+#[derive(Debug)]
+pub struct DrpcProvider {
+    pub client: Client<HttpsConnector<HttpConnector>>,
+    pub supported_chains: HashMap<String, String>,
+}
+
+impl Provider for DrpcProvider {
+    fn supports_caip_chainid(&self, chain_id: &str) -> bool {
+        self.supported_chains.contains_key(chain_id)
+    }
+
+    fn supported_caip_chains(&self) -> Vec<String> {
+        self.supported_chains.keys().cloned().collect()
+    }
+
+    fn provider_kind(&self) -> ProviderKind {
+        ProviderKind::Drpc
+    }
+}
+
+#[async_trait]
+impl RateLimited for DrpcProvider {
+    async fn is_rate_limited(&self, response: &mut Response) -> bool {
+        response.status() == http::StatusCode::TOO_MANY_REQUESTS
+    }
+}
+
+#[async_trait]
+impl RpcProvider for DrpcProvider {
+    #[tracing::instrument(skip(self, body), fields(provider = %self.provider_kind()), level = "debug")]
+    async fn proxy(&self, chain_id: &str, body: hyper::body::Bytes) -> RpcResult<Response> {
+        let uri = self
+            .supported_chains
+            .get(chain_id)
+            .ok_or(RpcError::ChainNotFound)?;
+
+        let hyper_request = hyper::http::Request::builder()
+            .method(Method::POST)
+            .uri(uri)
+            .header("Content-Type", "application/json")
+            .body(hyper::body::Body::from(body))?;
+
+        let response = self.client.request(hyper_request).await?;
+        let status = response.status();
+        let body = hyper::body::to_bytes(response.into_body()).await?;
+
+        if let Ok(response) = serde_json::from_slice::<jsonrpc::Response>(&body) {
+            if response.error.is_some() && status.is_success() {
+                debug!(
+                    "Strange: provider returned JSON RPC error, but status {status} is success: \
+                 dRPC: {response:?}"
+                );
+            }
+        }
+
+        let mut response = (status, body).into_response();
+        response
+            .headers_mut()
+            .insert("Content-Type", HeaderValue::from_static("application/json"));
+        Ok(response)
+    }
+}
+
+impl RpcProviderFactory<DrpcConfig> for DrpcProvider {
+    #[tracing::instrument(level = "debug")]
+    fn new(provider_config: &DrpcConfig) -> Self {
+        let forward_proxy_client = Client::builder().build::<_, hyper::Body>(HttpsConnector::new());
+        let supported_chains: HashMap<String, String> = provider_config
+            .supported_chains
+            .iter()
+            .map(|(k, v)| (k.clone(), v.0.clone()))
+            .collect();
+
+        DrpcProvider {
+            client: forward_proxy_client,
+            supported_chains,
+        }
+    }
+}

src/providers/mod.rs

@@ -55,6 +55,7 @@ mod berachain;
 mod binance;
 mod bungee;
 mod coinbase;
+mod drpc;
 mod dune;
 mod getblock;
 mod infura;
@@ -84,6 +85,7 @@ pub use {
     berachain::BerachainProvider,
     binance::BinanceProvider,
     bungee::BungeeProvider,
+    drpc::DrpcProvider,
     dune::DuneProvider,
     getblock::GetBlockProvider,
     infura::{InfuraProvider, InfuraWsProvider},
@@ -630,6 +632,7 @@ pub enum ProviderKind {
     Tenderly,
     Dune,
     Wemix,
+    Drpc,
 }
 
 impl Display for ProviderKind {
@@ -663,6 +666,7 @@ impl Display for ProviderKind {
                 ProviderKind::Morph => "Morph",
                 ProviderKind::Tenderly => "Tenderly",
                 ProviderKind::Dune => "Dune",
+                ProviderKind::Drpc => "Drpc",
             }
         )
     }
@@ -697,6 +701,7 @@ impl ProviderKind {
             "Tenderly" => Some(Self::Tenderly),
             "Dune" => Some(Self::Dune),
             "Wemix" => Some(Self::Wemix),
+            "Drpc" => Some(Self::Drpc),
             _ => None,
         }
     }

tests/functional/http/drpc.rs

@@ -0,0 +1,19 @@
+use {
+    super::check_if_rpc_is_responding_correctly_for_solana, crate::context::ServerContext,
+    rpc_proxy::providers::ProviderKind, test_context::test_context,
+};
+
+#[test_context(ServerContext)]
+#[tokio::test]
+#[ignore]
+async fn drpc_provider_solana(ctx: &mut ServerContext) {
+    let provider = ProviderKind::Drpc;
+
+    // Solana mainnet
+    check_if_rpc_is_responding_correctly_for_solana(
+        ctx,
+        "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+        &provider,
+    )
+    .await;
+}

tests/functional/http/mod.rs

@@ -11,6 +11,7 @@ pub(crate) mod aurora;
 pub(crate) mod base;
 pub(crate) mod berachain;
 pub(crate) mod binance;
+pub(crate) mod drpc;
 pub(crate) mod getblock;
 pub(crate) mod infura;
 pub(crate) mod lava;