[SEQ-115] feat: Add skeleton of metabased sequencer (#1)

* chore: cargo init

* chore: Install alloy

* wip: JSON RPC skeleton

* chore: Add support for eth_sendRawTransaction

* chore: Reject eth_sendTransaction

* chore: Add JSON-RPC import

* chore: Switch to jsonrpsee from deprecated jsonrpc package

* feat: Switch to jsonrpsee middleware example

* fix: Fix jsonrpsee install

* chore: Import serde

* chore: Add remaining imports and fix build

* chore: Remove build warnings for unused import

Also switch to more modern way to handle tracing_subscriber formatting

* chore: Add GitHub Action to run cargo

* chore: Update checkout version and toolchain override

* chore: Update GitHub Action with rust-toolchain

* chore: Add GitHub Action for Clippy Check

* chore: Update pull request logic for GH Action

* chore: Remove redundant import

* chore: Update clippy check

Uses https://doc.rust-lang.org/stable/clippy/continuous_integration/github_actions.html instead of the deprecated GitHub Action

* docs: Update TODOs for next steps

* test: Intentionally re-add redundant import to test Clippy Check failure

* Revert "test: Intentionally re-add redundant import to test Clippy Check failure"

This reverts commit 75653f8ca3a68bbebbe2390ede0796a407fe1220.

Author: WillPapper

.github/workflows/rust-clippy.yml

@@ -0,0 +1,24 @@
+name: Rust Clippy Check
+
+on:
+  pull_request:
+    branches: [main] # Adjust this if your main branch has a different name
+
+env:
+  CARGO_TERM_COLOR: always
+  # Make sure CI fails on all warnings, including Clippy lints
+  RUSTFLAGS: "-Dwarnings"
+
+jobs:
+  clippy_check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - run: rustup component add clippy
+
+      - name: Cache Cargo dependencies
+        uses: Swatinem/rust-cache@v2
+
+      - name: Run Clippy
+        run: cargo clippy --all-targets --all-features

.github/workflows/rust-tests.yml

@@ -0,0 +1,27 @@
+name: Rust Tests
+
+on:
+  pull_request:
+    branches: [main] # Adjust this if your main branch has a different name
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  test:
+    name: Run Rust Tests
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      # GitHub Actions supports rustup by default, so we can install the toolchain directly
+      # selecting a toolchain either by action or manual `rustup` calls should happen
+      # before the plugin, as the cache uses the current rustc version as its cache key
+      - run: rustup toolchain install stable --profile minimal
+
+      - name: Cache Cargo dependencies
+        uses: Swatinem/rust-cache@v2
+
+      - name: Run tests
+        run: cargo test --all

.gitignore

@@ -18,4 +18,8 @@ Cargo.lock
 #  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-#.idea/
+#.idea/
+
+# Added by cargo
+
+/target

Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "metabased-sequencer"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+alloy = { version = "0.3.1", features = ["full"] }
+# TODO: Opt into specific features
+jsonrpsee = { version = "0.24.3", features = ["full"] }
+tokio = { version = "1.0", features = ["full"] }
+anyhow = "1.0"
+serde_json = "1.0.128"
+tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }

rust-toolchain.toml

@@ -0,0 +1,8 @@
+[toolchain]
+channel = "stable"
+components = ["rustfmt", "clippy"]
+targets = [
+    "aarch64-apple-darwin",     # For M1 Mac
+    "x86_64-unknown-linux-gnu"  # For Linux server
+]
+profile = "default"

src/main.rs

@@ -0,0 +1,80 @@
+// Based on https://github.com/paritytech/jsonrpsee/blob/master/examples/examples/rpc_middleware_modify_request.rs
+
+use jsonrpsee::core::client::ClientT;
+use jsonrpsee::server::middleware::rpc::{RpcServiceBuilder, RpcServiceT};
+use jsonrpsee::server::Server;
+use jsonrpsee::types::Request;
+use jsonrpsee::ws_client::WsClientBuilder;
+use jsonrpsee::{rpc_params, RpcModule};
+use std::borrow::Cow as StdCow;
+use std::net::SocketAddr;
+use tracing_subscriber::EnvFilter;
+
+#[derive(Clone)]
+pub struct ModifyRequestIf<S>(S);
+
+impl<'a, S> RpcServiceT<'a> for ModifyRequestIf<S>
+where
+    S: Send + Sync + RpcServiceT<'a>,
+{
+    type Future = S::Future;
+
+    fn call(&self, mut req: Request<'a>) -> Self::Future {
+        // Example how to modify the params in the call.
+        // TODO: Change this to intercept eth_sendRawTransaction
+        if req.method == "say_hello" {
+            // It's a bit awkward to create new params in the request
+            // but this shows how to do it.
+            let raw_value = serde_json::value::to_raw_value("myparams").unwrap();
+            req.params = Some(StdCow::Owned(raw_value));
+        }
+        // Re-direct all calls that isn't `say_hello` to `say_goodbye`
+        // TODO: Change this to redirect all calls to the underlying RPC
+        // (optionally, via an env variable if you want to forward)
+        // If the node operator does not want to forward
+        // non-eth_sendRawTransaction calls, then reject all other calls
+        else if req.method != "say_hello" {
+            req.method = "say_goodbye".into();
+        }
+
+        self.0.call(req)
+    }
+}
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    tracing_subscriber::fmt()
+        .with_env_filter(EnvFilter::from_default_env())
+        .try_init()
+        .expect("setting default subscriber failed");
+
+    let addr = run_server().await?;
+    let url = format!("ws://{}", addr);
+
+    let client = WsClientBuilder::default().build(&url).await?;
+    let _response: String = client.request("say_hello", rpc_params![]).await?;
+    let _response: Result<String, _> = client.request("unknown_method", rpc_params![]).await;
+    let _: String = client.request("say_hello", rpc_params![]).await?;
+
+    Ok(())
+}
+
+async fn run_server() -> anyhow::Result<SocketAddr> {
+    let rpc_middleware = RpcServiceBuilder::new().layer_fn(ModifyRequestIf);
+    let server = Server::builder()
+        .set_rpc_middleware(rpc_middleware)
+        .build("127.0.0.1:0")
+        .await?;
+    let mut module = RpcModule::new(());
+    module.register_method("say_hello", |_, _, _| "lo")?;
+    module.register_method("say_goodbye", |_, _, _| "goodbye")?;
+    let addr = server.local_addr()?;
+
+    let handle = server.start(module);
+
+    // In this example we don't care about doing shutdown so let's it run forever.
+    // You may use the `ServerHandle` to shut it down or manage it yourself.
+    tokio::spawn(handle.stopped());
+
+    Ok(addr)
+}