Merge pull request #31 from loadnetwork/helios

chore: refactors

Author: charmful0x

native/helios_nif/src/core/light_client.rs

@@ -1,148 +1,18 @@
-use alloy::{
-    eips::BlockId,
-    primitives::{Address, B256, Bytes, U256},
-    rpc::types::{Filter, Log},
-};
+use alloy::eips::BlockId;
 use anyhow::Error;
-use helios::ethereum::{EthereumClientBuilder, config::networks::Network};
-use hyper::{
-    Body, Method, Request, Response, Server, StatusCode,
-    service::{make_service_fn, service_fn},
-};
-use serde::{Deserialize, Serialize};
+use hyper::{Body, Method, Request, Response, StatusCode};
 use serde_json::{Value, json};
 use std::convert::Infallible;
-use std::net::SocketAddr;
-use std::path::PathBuf;
-use std::str::FromStr;
 use std::sync::{Arc, Mutex};
-use tokio::runtime::Runtime;
-use tokio::sync::oneshot;
 use tracing::{error, info};
-use tracing_subscriber::FmtSubscriber;
-use tracing_subscriber::filter::{EnvFilter, LevelFilter};
-
-#[derive(Deserialize, Debug)]
-struct JsonRpcRequest {
-    jsonrpc: String,
-    method: String,
-    params: Vec<Value>,
-    id: Value,
-}
-
-#[derive(Serialize)]
-struct JsonRpcResponse {
-    jsonrpc: String,
-    result: Value,
-    id: Value,
-}
-
-#[derive(Serialize)]
-struct JsonRpcErrorResponse {
-    jsonrpc: String,
-    error: JsonRpcError,
-    id: Value,
-}
-
-#[derive(Serialize)]
-struct JsonRpcError {
-    code: i32,
-    message: String,
-}
-
-struct ServerState {
-    client: Arc<helios::ethereum::EthereumClient>,
-    shutdown_signal: Option<oneshot::Receiver<()>>,
-}
-
-fn parse_block_id(value: &Value) -> Result<BlockId, Error> {
-    match value {
-        Value::String(s) => {
-            if s == "latest" {
-                Ok(BlockId::latest())
-            } else if s == "earliest" {
-                Ok(BlockId::earliest())
-            } else if s == "pending" {
-                Ok(BlockId::pending())
-            } else if s == "safe" {
-                Ok(BlockId::safe())
-            } else if s == "finalized" {
-                Ok(BlockId::finalized())
-            } else if s.starts_with("0x") {
-                // Try to parse as block hash
-                let hash = B256::from_str(s)
-                    .map_err(|e| Error::msg(format!("Invalid block hash: {}", e)))?;
-                Ok(BlockId::Hash(hash.into()))
-            } else {
-                // Try to parse as block number
-                let num = s
-                    .parse::<u64>()
-                    .map_err(|e| Error::msg(format!("Invalid block number: {}", e)))?;
-                Ok(BlockId::Number(num.into()))
-            }
-        }
-        Value::Number(n) => {
-            if let Some(num) = n.as_u64() {
-                Ok(BlockId::Number(num.into()))
-            } else {
-                Err(Error::msg("Invalid block number"))
-            }
-        }
-        _ => Err(Error::msg("Invalid block identifier")),
-    }
-}
-
-fn parse_address(value: &Value) -> Result<Address, Error> {
-    match value {
-        Value::String(s) => {
-            Address::from_str(s).map_err(|e| Error::msg(format!("Invalid address: {}", e)))
-        }
-        _ => Err(Error::msg("Invalid address format")),
-    }
-}
-
-fn parse_b256(value: &Value) -> Result<B256, Error> {
-    match value {
-        Value::String(s) => {
-            B256::from_str(s).map_err(|e| Error::msg(format!("Invalid hash: {}", e)))
-        }
-        _ => Err(Error::msg("Invalid hash format")),
-    }
-}
-
-fn parse_u256(value: &Value) -> Result<U256, Error> {
-    match value {
-        Value::String(s) => {
-            U256::from_str(s).map_err(|e| Error::msg(format!("Invalid U256: {}", e)))
-        }
-        Value::Number(n) => {
-            if let Some(num) = n.as_u64() {
-                Ok(U256::from(num))
-            } else {
-                Err(Error::msg("Invalid U256 number"))
-            }
-        }
-        _ => Err(Error::msg("Invalid U256 format")),
-    }
-}
 
-fn parse_bytes(value: &Value) -> Result<Bytes, Error> {
-    match value {
-        Value::String(s) => {
-            if s.starts_with("0x") {
-                let s = s.trim_start_matches("0x");
-                let bytes =
-                    hex::decode(s).map_err(|e| Error::msg(format!("Invalid hex: {}", e)))?;
-                Ok(Bytes::from(bytes))
-            } else {
-                Err(Error::msg("Hex string must start with 0x"))
-            }
-        }
-        _ => Err(Error::msg("Invalid bytes format")),
-    }
-}
+use crate::core::server::create_error_response;
+use crate::core::types::{
+    JsonRpcError, JsonRpcErrorResponse, JsonRpcRequest, JsonRpcResponse, ServerState,
+};
+use crate::core::utils::{parse_address, parse_b256, parse_block_id, parse_bytes, parse_u256};
 
-async fn handle_request(
+pub async fn handle_request(
     req: Request<Body>,
     state: Arc<Mutex<ServerState>>,
 ) -> Result<Response<Body>, Infallible> {
@@ -441,104 +311,3 @@ async fn handle_request(
 
     Ok(response)
 }
-
-fn create_error_response(
-    code: i32,
-    message: &str,
-    id: Value,
-) -> Result<Response<Body>, Infallible> {
-    let error_response = JsonRpcErrorResponse {
-        jsonrpc: "2.0".to_string(),
-        error: JsonRpcError {
-            code,
-            message: message.to_string(),
-        },
-        id,
-    };
-
-    let mut response = Response::new(Body::from(serde_json::to_string(&error_response).unwrap()));
-    response.headers_mut().insert(
-        hyper::header::CONTENT_TYPE,
-        hyper::header::HeaderValue::from_static("application/json"),
-    );
-
-    Ok(response)
-}
-
-pub fn start_server(
-    address: SocketAddr,
-    execution_rpc: String,
-    consensus_rpc: String,
-    data_dir: PathBuf,
-    shutdown_rx: oneshot::Receiver<()>,
-) -> Result<Runtime, Error> {
-    let env_filter = EnvFilter::builder()
-        .with_default_directive(LevelFilter::INFO.into())
-        .from_env_lossy();
-
-    let subscriber = FmtSubscriber::builder()
-        .with_env_filter(env_filter)
-        .finish();
-
-    let _ = tracing::subscriber::set_global_default(subscriber);
-
-    let runtime = Runtime::new()?;
-
-    let client = runtime.block_on(async {
-        info!(target: "helios::server", "Building Helios client...");
-
-        let client = EthereumClientBuilder::new()
-            .network(Network::Mainnet)
-            .execution_rpc(&execution_rpc)
-            .unwrap()
-            .consensus_rpc(&consensus_rpc)
-            .unwrap()
-            .data_dir(data_dir)
-            .with_file_db()
-            .build()
-            .unwrap();
-
-        info!(target: "helios::server", "Helios client built successfully");
-
-        Ok::<_, Error>(client)
-    })?;
-
-    let state = Arc::new(Mutex::new(ServerState {
-        client: Arc::new(client),
-        shutdown_signal: Some(shutdown_rx),
-    }));
-
-    let state_clone = state.clone();
-
-    runtime.spawn(async move {
-        info!(target: "helios::server", "Starting HTTP server on {}", address);
-        
-        let make_svc = make_service_fn(move |_conn| {
-            let state = state_clone.clone();
-            async move {
-                Ok::<_, Infallible>(service_fn(move |req| {
-                    handle_request(req, state.clone())
-                }))
-            }
-        });
-        
-        let server = Server::bind(&address).serve(make_svc);
-        
-        let shutdown_signal = {
-            let mut state = state.lock().unwrap();
-            state.shutdown_signal.take().unwrap()
-        };
-        
-        let server = server.with_graceful_shutdown(async {
-            shutdown_signal.await.ok();
-            info!(target: "helios::server", "Server shutting down gracefully");
-        });
-        
-        info!(target: "helios::server", "HTTP server running at {}", address);
-        if let Err(e) = server.await {
-            error!(target: "helios::server", "Server error: {}", e);
-        }
-    });
-
-    Ok(runtime)
-}

native/helios_nif/src/core/mod.rs

@@ -1 +1,4 @@
 pub mod light_client;
+pub mod server;
+pub mod types;
+pub mod utils;

native/helios_nif/src/core/server.rs

@@ -0,0 +1,119 @@
+use anyhow::Error;
+use helios::ethereum::{EthereumClientBuilder, config::networks::Network};
+use hyper::{
+    Body, Response, Server,
+    service::{make_service_fn, service_fn},
+};
+use serde_json::Value;
+use std::convert::Infallible;
+use std::net::SocketAddr;
+use std::path::PathBuf;
+use std::sync::{Arc, Mutex};
+use tokio::runtime::Runtime;
+use tokio::sync::oneshot;
+use tracing::{error, info};
+use tracing_subscriber::FmtSubscriber;
+use tracing_subscriber::filter::{EnvFilter, LevelFilter};
+
+use crate::core::light_client::handle_request;
+use crate::core::types::{JsonRpcError, JsonRpcErrorResponse, ServerState};
+
+pub fn create_error_response(
+    code: i32,
+    message: &str,
+    id: Value,
+) -> Result<Response<Body>, Infallible> {
+    let error_response = JsonRpcErrorResponse {
+        jsonrpc: "2.0".to_string(),
+        error: JsonRpcError {
+            code,
+            message: message.to_string(),
+        },
+        id,
+    };
+
+    let mut response = Response::new(Body::from(serde_json::to_string(&error_response).unwrap()));
+    response.headers_mut().insert(
+        hyper::header::CONTENT_TYPE,
+        hyper::header::HeaderValue::from_static("application/json"),
+    );
+
+    Ok(response)
+}
+
+pub fn start_server(
+    address: SocketAddr,
+    execution_rpc: String,
+    consensus_rpc: String,
+    data_dir: PathBuf,
+    shutdown_rx: oneshot::Receiver<()>,
+) -> Result<Runtime, Error> {
+    let env_filter = EnvFilter::builder()
+        .with_default_directive(LevelFilter::INFO.into())
+        .from_env_lossy();
+
+    let subscriber = FmtSubscriber::builder()
+        .with_env_filter(env_filter)
+        .finish();
+
+    let _ = tracing::subscriber::set_global_default(subscriber);
+
+    let runtime = Runtime::new()?;
+
+    let client = runtime.block_on(async {
+        info!(target: "helios::server", "Building Helios client...");
+
+        let client = EthereumClientBuilder::new()
+            .network(Network::Mainnet)
+            .execution_rpc(&execution_rpc)
+            .unwrap()
+            .consensus_rpc(&consensus_rpc)
+            .unwrap()
+            .data_dir(data_dir)
+            .with_file_db()
+            .build()
+            .unwrap();
+
+        info!(target: "helios::server", "Helios client built successfully");
+
+        Ok::<_, Error>(client)
+    })?;
+
+    let state = Arc::new(Mutex::new(ServerState {
+        client: Arc::new(client),
+        shutdown_signal: Some(shutdown_rx),
+    }));
+
+    let state_clone = state.clone();
+
+    runtime.spawn(async move {
+        info!(target: "helios::server", "Starting HTTP server on {}", address);
+
+        let make_svc = make_service_fn(move |_conn| {
+            let state = state_clone.clone();
+            async move {
+                Ok::<_, Infallible>(service_fn(move |req| {
+                    handle_request(req, state.clone())
+                }))
+            }
+        });
+
+        let server = Server::bind(&address).serve(make_svc);
+        let shutdown_signal = {
+            let mut state = state.lock().unwrap();
+            state.shutdown_signal.take().unwrap()
+        };
+
+        let server = server.with_graceful_shutdown(async {
+            shutdown_signal.await.ok();
+            info!(target: "helios::server", "Server shutting down gracefully");
+        });
+
+        info!(target: "helios::server", "HTTP server running at {}", address);
+        if let Err(e) = server.await {
+            error!(target: "helios::server", "Server error: {}", e);
+        }
+    });
+
+    Ok(runtime)
+}