Add Auth Methods for http and ws

packages/ciphernode/evm/Cargo.toml

@@ -10,14 +10,15 @@ alloy-primitives = { workspace = true }
 anyhow = { workspace = true }
 async-trait = { workspace = true }
 base64 = { workspace = true }
-enclave-core = { path = "../core" }
+cipher = { path = "../cipher" }
+config = { path = "../config" }
 data = { path = "../data" }
+enclave-core = { path = "../core" }
 futures-util = { workspace = true }
 sortition = { path = "../sortition" }
-cipher = { path = "../cipher" }
+serde = { workspace = true }
 tokio = { workspace = true }
 tracing = { workspace = true }
-serde = { workspace = true }
 url = { workspace = true }
 zeroize = { workspace = true }
 

packages/ciphernode/evm/src/helpers.rs

@@ -7,15 +7,29 @@ use alloy::{
         },
         Identity, Provider, ProviderBuilder, RootProvider,
     },
+    pubsub::PubSubFrontend,
+    rpc::client::RpcClient,
     signers::local::PrivateKeySigner,
-    transports::{BoxTransport, Transport},
+    transports::{
+        http::{
+            reqwest::{
+                header::{HeaderMap, HeaderValue, AUTHORIZATION},
+                Client,
+            },
+            Http,
+        },
+        ws::WsConnect,
+        Authorization, BoxTransport, Transport,
+    },
 };
 use anyhow::{bail, Context, Result};
+use base64::{engine::general_purpose::STANDARD, Engine};
 use cipher::Cipher;
 use data::Repository;
 use std::{env, marker::PhantomData, sync::Arc};
 use url::Url;
 use zeroize::Zeroizing;
+use config::RpcAuth as ConfigRpcAuth;
 
 #[derive(Clone)]
 pub enum RPC {
@@ -110,6 +124,63 @@ where
     }
 }
 
+#[derive(Clone)]
+pub enum RpcAuth {
+    None,
+    Basic {
+        username: String,
+        password: String,
+    },
+    Bearer(String)
+}
+
+impl RpcAuth {
+    fn to_header_value(&self) -> Option<HeaderValue> {
+        match self {
+            RpcAuth::None => None,
+            RpcAuth::Basic { username, password } => {
+                let auth = format!(
+                    "Basic {}",
+                    STANDARD.encode(format!("{}:{}", username, password))
+                );
+                HeaderValue::from_str(&auth).ok()
+            }
+            RpcAuth::Bearer(token) => HeaderValue::from_str(&format!("Bearer {}", token)).ok(),
+        }
+    }
+
+    fn to_ws_auth(&self) -> Option<Authorization> {
+        match self {
+            RpcAuth::None => None,
+            RpcAuth::Basic { username, password } => {
+                Some(Authorization::basic(username, password))
+            }
+            RpcAuth::Bearer(token) => Some(Authorization::bearer(token)),
+        }
+    }
+}
+
+
+impl From<ConfigRpcAuth> for RpcAuth {
+    fn from(value: ConfigRpcAuth) -> Self {
+        match value {
+            ConfigRpcAuth::None => RpcAuth::None,
+            ConfigRpcAuth::Basic { username, password } => RpcAuth::Basic { username, password },
+            ConfigRpcAuth::Bearer(token) => RpcAuth::Bearer(token),
+        }
+    }
+}
+
+impl From<RpcAuth> for ConfigRpcAuth {
+    fn from(value: RpcAuth) -> Self {
+        match value {
+            RpcAuth::None => ConfigRpcAuth::None,
+            RpcAuth::Basic { username, password } => ConfigRpcAuth::Basic { username, password },
+            RpcAuth::Bearer(token) => ConfigRpcAuth::Bearer(token),
+        }
+    }
+}
+
 pub type ReadonlyProvider = RootProvider<BoxTransport>;
 
 pub async fn create_readonly_provider(