Refactor identity-sequencer into world-tree

Cargo.toml

@@ -1,28 +1,36 @@
 [package]
-name = "identity-sequencer"
+name = "world-tree"
 version = "0.1.0"
 edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
-[workspace]
-members = [
-  "crates/common",
-  "crates/sequencer",
-  "crates/state_bridge",
-  "crates/tree_availability"]
-
 [dependencies]
-clap = { version = "4.4.6", features = ["derive"] }
-common = { path = "./crates/common" }
-ethers = "2.0.10"
+anyhow = "1.0.75"
+axum = "0.6.20"
+axum-middleware = { path = "crates/axum_middleware" }
+clap = { version = "4.4.7", features = ["derive"] }
+common = { path = "crates/common" }
+ethers = { version = "2.0.10", features = ["abigen", "ws", "ipc", "rustls", "openssl"] }
 eyre = "0.6.8"
 futures = "0.3.28"
-serde = "1.0.188"
-state_bridge = { path = "crates/state_bridge" }
-tokio = { version = "1.33.0", features = ["full"] }
-toml = "0.8.4"
-tracing = "0.1.40"
-tree_availability = { path = "crates/tree_availability" }
+hex = "0.4.3"
+hyper = { version = "^0.14.27", features = ["server", "tcp", "http1", "http2"] }
+metrics = "0.21.1"
+opentelemetry = "0.20.0"
+ruint = "1.10.1"
+semaphore = { git = "https://github.com/worldcoin/semaphore-rs", branch = "main", features = [
+    "depth_20",
+] }
+serde = { version = "1.0.189", features = ["derive"] }
+serde_json = "1.0.107"
+take_mut = "0.2.2"
+thiserror = "1.0.49"
+tokio = { version = "1.32.0", features = ["sync", "macros"] }
+toml = "0.8.8"
+tracing = "0.1.37"
+
+[dev-dependencies]
+reqwest = { version = "0.11.22", features = ["json"] }
 
 [[bin]]
 name = "tree-availability-service"

README.md

@@ -1 +1 @@
-# identity-sequencer
+# world-tree

bin/state_bridge_service.rs

@@ -13,13 +13,12 @@ use ethers::prelude::{
 use ethers::providers::Middleware;
 use futures::stream::FuturesUnordered;
 use futures::StreamExt;
+use opentelemetry::global::shutdown_tracer_provider;
 use serde::{Deserialize, Serialize};
-use state_bridge::abi::{
-    IBridgedWorldID, IStateBridge, IWorldIDIdentityManager,
-};
-use state_bridge::bridge::StateBridge;
-use state_bridge::StateBridgeService;
 use tracing::Level;
+use world_tree::abi::{IBridgedWorldID, IStateBridge};
+use world_tree::state_bridge::service::StateBridgeService;
+use world_tree::state_bridge::StateBridge;
 
 #[derive(Parser, Debug)]
 #[clap(
@@ -131,11 +130,12 @@ async fn spawn_state_bridge_service(
         NonceManagerMiddleware::new(signer_middleware, wallet_address);
     let middleware = Arc::new(nonce_manager_middleware);
 
-    let world_id_interface =
-        IWorldIDIdentityManager::new(world_id_address, middleware.clone());
-
     let mut state_bridge_service =
-        StateBridgeService::new(world_id_interface).await?;
+        StateBridgeService::new(world_id_address, middleware).await?;
+
+    let wallet = private_key
+        .parse::<LocalWallet>()
+        .expect("couldn't instantiate wallet from private key");
 
     for bridge_config in bridge_configs {
         let BridgeConfig {
@@ -145,29 +145,15 @@ async fn spawn_state_bridge_service(
             ..
         } = bridge_config;
 
-        let bridged_provider = Provider::<Http>::try_from(bridged_rpc_url)
-            .expect("failed to initialize Http provider");
-
-        let chain_id = bridged_provider.get_chainid().await?.as_u64();
-
-        let wallet = private_key
-            .parse::<LocalWallet>()
-            .expect("couldn't instantiate wallet from private key")
-            .with_chain_id(chain_id);
-        let wallet_address = wallet.address();
-
-        let bridged_middleware =
-            SignerMiddleware::new(bridged_provider, wallet);
-        let bridged_middleware =
-            NonceManagerMiddleware::new(bridged_middleware, wallet_address);
-        let bridged_middleware = Arc::new(bridged_middleware);
+        let l2_middleware =
+            initialize_l2_middleware(&bridged_rpc_url, wallet.clone()).await?;
 
         let state_bridge_interface =
-            IStateBridge::new(state_bridge_address, middleware.clone());
+            IStateBridge::new(state_bridge_address, l2_middleware.clone());
 
         let bridged_world_id_interface = IBridgedWorldID::new(
             bridged_world_id_address,
-            bridged_middleware.clone(),
+            l2_middleware.clone(),
         );
 
         let state_bridge = StateBridge::new(
@@ -181,12 +167,36 @@ async fn spawn_state_bridge_service(
     }
 
     tracing::info!("Spawning state bridge service");
-    let handles = state_bridge_service.spawn().await?;
+    let handles = state_bridge_service.spawn()?;
 
     let mut handles = handles.into_iter().collect::<FuturesUnordered<_>>();
     while let Some(result) = handles.next().await {
+        tracing::error!("StateBridgeError: {:?}", result);
+
         result??;
     }
 
     Ok(())
 }
+
+pub async fn initialize_l2_middleware(
+    l2_rpc_endpoint: &str,
+    wallet: LocalWallet,
+) -> eyre::Result<
+    Arc<NonceManagerMiddleware<SignerMiddleware<Provider<Http>, LocalWallet>>>,
+> {
+    let l2_provider = Provider::<Http>::try_from(l2_rpc_endpoint)?;
+    let chain_id = l2_provider.get_chainid().await?.as_u64();
+
+    let wallet = wallet.with_chain_id(chain_id);
+    let wallet_address = wallet.address();
+
+    let signer_middleware = SignerMiddleware::new(l2_provider, wallet);
+
+    let nonce_manager_middleware =
+        NonceManagerMiddleware::new(signer_middleware, wallet_address);
+
+    let l2_middleware = Arc::new(nonce_manager_middleware);
+
+    Ok(l2_middleware)
+}

bin/tree_availability_service.rs

@@ -9,7 +9,7 @@ use ethers::types::H160;
 use futures::stream::FuturesUnordered;
 use futures::StreamExt;
 use tracing::Level;
-use tree_availability::TreeAvailabilityService;
+use world_tree::tree::service::TreeAvailabilityService;
 
 #[derive(Parser, Debug)]
 #[clap(
@@ -79,8 +79,7 @@ pub async fn main() -> eyre::Result<()> {
         opts.window_size,
         middleware,
     )
-    .serve(opts.port)
-    .await;
+    .serve(opts.port);
 
     let mut handles = handles.into_iter().collect::<FuturesUnordered<_>>();
     while let Some(result) = handles.next().await {

crates/axum_middleware/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "axum-middleware"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+tracing = "0.1.40"
+axum = "0.6.20"
+hyper = { version = "^0.14.27", features = ["server", "tcp", "http1", "http2"] }
+bytes = "1.5.0"
+futures-util = "0.3.29"
+common = { path = "../common" }

crates/common/Cargo.toml

@@ -15,7 +15,7 @@ eyre = "0.6.8"
 serde = "1.0.189"
 metrics = "0.21.1"
 opentelemetry = { version = "0.20.0", features = ["rt-tokio"] }
-opentelemetry-datadog = {verison = "0.8.0", features = ["reqwest-client"]}
+opentelemetry-datadog = {version = "0.8.0", features = ["reqwest-client"]}
 tracing = "0.1.40"
 tracing-opentelemetry = "0.21.0"
 tracing-subscriber = {version = "0.3.17", features = ["env-filter", "json"]}

crates/common/src/tracing.rs

@@ -5,20 +5,20 @@ use chrono::Utc;
 use opentelemetry::sdk::trace;
 use opentelemetry::sdk::trace::Sampler;
 use opentelemetry::trace::TraceContextExt;
-use serde::ser::{SerializeMap, Serializer as _};
+use serde::ser::SerializeMap;
+use serde::Serializer;
 use tokio::sync::OnceCell;
 use tracing::{Event, Level, Subscriber};
 use tracing_appender::non_blocking::WorkerGuard;
 use tracing_opentelemetry::{OpenTelemetrySpanExt, OtelData};
 use tracing_serde::fields::AsMap;
 use tracing_serde::AsSerde;
-use tracing_subscriber::filter::EnvFilter;
-use tracing_subscriber::fmt;
 use tracing_subscriber::fmt::format::Writer;
 use tracing_subscriber::fmt::{FmtContext, FormatEvent, FormatFields};
 use tracing_subscriber::prelude::__tracing_subscriber_SubscriberExt;
 use tracing_subscriber::registry::{LookupSpan, SpanRef};
 use tracing_subscriber::util::SubscriberInitExt;
+use tracing_subscriber::{fmt, EnvFilter};
 
 static WORKER_GUARD: OnceCell<WorkerGuard> = OnceCell::const_new();
 
@@ -53,7 +53,7 @@ pub fn init_datadog_subscriber(service_name: &str, level: Level) {
     let file_appender = tracing_appender::rolling::RollingFileAppender::new(
         //TODO: do we want this to be dynamic
         tracing_appender::rolling::Rotation::DAILY,
-        get_log_directory(),
+        get_log_directory().expect("TODO:handle this error"),
         format!("{service_name}.log"),
     );