feat: add basic RPC api.

.github/workflows/ci.yaml

@@ -0,0 +1,35 @@
+name: CI
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: ["*"]
+
+concurrency:
+  group: ${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+jobs:
+  compile:
+    name: Compile
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v3
+
+      - name: Rustup toolchain install
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: stable
+
+      - name: Set up cargo cache
+        uses: Swatinem/rust-cache@v2
+
+      - name: Run cargo check
+        run: cargo check
+
+      - name: Run cargo build
+        run: |
+          cargo build
+
+

Cargo.toml

@@ -6,7 +6,10 @@ members = [
     "crates/net",
     "crates/rpc",
     "crates/storage",
+    "ethereum_rust",
 ]
+resolver = "2"
+
 
 [workspace.package]
 name = "ethereum_rust"

crates/rpc/Cargo.toml

@@ -6,3 +6,9 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+axum = "0.7.5"
+serde = { version = "1.0.203", features = ["derive"] }
+serde_json = "1.0.117"
+tokio = { version = "1.38.0", features = ["full"] }
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }

crates/rpc/src/engine/capabilities.rs

@@ -0,0 +1,9 @@
+use serde_json::Value;
+
+use crate::RpcErr;
+
+// type ExchangeCapabilities = Vec<String>;
+
+pub fn exchange_capabilities() -> Result<Value, RpcErr> {
+    Ok(Value::Array(vec![]))
+}

crates/rpc/src/engine/mod.rs

@@ -0,0 +1 @@
+pub(crate) mod capabilities;

crates/rpc/src/eth/block.rs

@@ -0,0 +1,7 @@
+use serde_json::Value;
+
+use crate::utils::RpcErr;
+
+pub fn get_block_by_number() -> Result<Value, RpcErr> {
+    Ok(Value::Null)
+}

crates/rpc/src/eth/client.rs

@@ -0,0 +1,11 @@
+use serde_json::Value;
+
+use crate::utils::RpcErr;
+
+pub fn chain_id() -> Result<Value, RpcErr> {
+    Ok(Value::String("0xaa36a7".to_string()))
+}
+
+pub fn syncing() -> Result<Value, RpcErr> {
+    Ok(Value::Bool(false))
+}

crates/rpc/src/eth/mod.rs

@@ -0,0 +1,2 @@
+pub(crate) mod block;
+pub(crate) mod client;

crates/rpc/src/lib.rs

@@ -1,14 +1,53 @@
-pub fn add(left: usize, right: usize) -> usize {
-    left + right
+use axum::{routing::post, Json, Router};
+use engine::capabilities::exchange_capabilities;
+use eth::{
+    block::get_block_by_number,
+    client::{chain_id, syncing},
+};
+use serde_json::Value;
+use utils::{RpcErr, RpcErrorResponse, RpcRequest, RpcSuccessResponse};
+
+mod engine;
+mod eth;
+mod utils;
+
+#[tokio::main]
+pub async fn start_api() {
+    tracing_subscriber::fmt::init();
+
+    let app = Router::new().route("/", post(handle_request));
+
+    let listener = tokio::net::TcpListener::bind("0.0.0.0:8551").await.unwrap();
+    axum::serve(listener, app).await.unwrap();
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
+pub async fn handle_request(body: String) -> Json<Value> {
+    let req: RpcRequest = serde_json::from_str(&body).unwrap();
+
+    let res: Result<Value, RpcErr> = match req.method.as_str() {
+        "engine_exchangeCapabilities" => exchange_capabilities(),
+        "eth_chainId" => chain_id(),
+        "eth_syncing" => syncing(),
+        "eth_getBlockByNumber" => get_block_by_number(),
+        _ => Err(RpcErr::MethodNotFound),
+    };
 
-    #[test]
-    fn it_works() {
-        let result = add(2, 2);
-        assert_eq!(result, 4);
+    match res {
+        Ok(result) => Json(
+            serde_json::to_value(&RpcSuccessResponse {
+                id: req.id,
+                jsonrpc: "2.0".to_string(),
+                result: result,
+            })
+            .unwrap(),
+        ),
+        Err(error) => Json(
+            serde_json::to_value(&RpcErrorResponse {
+                id: req.id,
+                jsonrpc: "2.0".to_string(),
+                error: error.into(),
+            })
+            .unwrap(),
+        ),
     }
 }

crates/rpc/src/utils.rs

@@ -0,0 +1,45 @@
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+pub enum RpcErr {
+    MethodNotFound,
+}
+
+impl Into<RpcErrorMetadata> for RpcErr {
+    fn into(self) -> RpcErrorMetadata {
+        match self {
+            RpcErr::MethodNotFound => RpcErrorMetadata {
+                code: -32601,
+                message: "Method not found".to_string(),
+            },
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct RpcRequest {
+    pub id: i32,
+    pub jsonrpc: String,
+    pub method: String,
+    pub params: Option<Value>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct RpcErrorMetadata {
+    pub code: i32,
+    pub message: String,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct RpcSuccessResponse {
+    pub id: i32,
+    pub jsonrpc: String,
+    pub result: Value,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct RpcErrorResponse {
+    pub id: i32,
+    pub jsonrpc: String,
+    pub error: RpcErrorMetadata,
+}

ethereum_rust/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "ethereum_rust"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+rpc = { path = "../crates/rpc" }

ethereum_rust/src/main.rs

@@ -0,0 +1,3 @@
+fn main() {
+    rpc::start_api();
+}