Add mock collector

Cargo.toml

@@ -1,3 +1,9 @@
+[workspace]
+members = [
+    ".",
+    "crates/mock-collector"
+]
+
 [package]
 name = "gas-agent"
 version = "0.1.1"

crates/mock-collector/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "mock-collector"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+gas-agent = { path = "../.." }
+tokio = { version = "1.44", features = ["full"] }
+axum = "0.7"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }

crates/mock-collector/src/main.rs

@@ -0,0 +1,90 @@
+use axum::{
+    extract::rejection::JsonRejection, http::StatusCode, response::IntoResponse, routing::post,
+    Router,
+};
+use gas_agent::AgentPayload;
+use serde::{Deserialize, Serialize};
+use std::net::SocketAddr;
+use tracing::{info, warn};
+
+/// The payload structure sent by the gas agent
+#[derive(Debug, Deserialize, Serialize)]
+struct AgentSubmission {
+    payload: AgentPayload,
+    signature: String,
+    network_signature: String,
+}
+
+async fn handle_agent_publish(
+    payload: Result<axum::Json<AgentSubmission>, JsonRejection>,
+) -> impl IntoResponse {
+    match payload {
+        Ok(axum::Json(submission)) => {
+            info!("═══════════════════════════════════════════════════════════════");
+            info!("RECEIVED AGENT SUBMISSION");
+            info!("═══════════════════════════════════════════════════════════════");
+            info!("System:         {:?}", submission.payload.system);
+            info!("Network:        {:?}", submission.payload.network);
+            info!("From Block:     {}", submission.payload.from_block);
+            info!("Settlement:     {:?}", submission.payload.settlement);
+            info!(
+                "Price:          {} {:?}",
+                submission.payload.price, submission.payload.unit
+            );
+            info!("Timestamp:      {}", submission.payload.timestamp);
+            info!("Schema Version: {}", submission.payload.schema_version);
+            info!("───────────────────────────────────────────────────────────────");
+            info!(
+                "Signature:         {}...",
+                &submission.signature[..20.min(submission.signature.len())]
+            );
+            info!(
+                "Network Signature: {}...",
+                &submission.network_signature[..20.min(submission.network_signature.len())]
+            );
+            info!("═══════════════════════════════════════════════════════════════");
+            (StatusCode::OK, "OK".to_string())
+        }
+        Err(rejection) => {
+            warn!("═══════════════════════════════════════════════════════════════");
+            warn!("INVALID PAYLOAD RECEIVED");
+            warn!("═══════════════════════════════════════════════════════════════");
+            warn!("Error: {}", rejection);
+            if let JsonRejection::JsonDataError(ref err) = rejection {
+                warn!("Details: {}", err.body_text());
+            } else if let JsonRejection::JsonSyntaxError(ref err) = rejection {
+                warn!("Details: {}", err.body_text());
+            }
+            warn!("═══════════════════════════════════════════════════════════════");
+            (
+                StatusCode::BAD_REQUEST,
+                format!("Invalid payload: {}", rejection),
+            )
+        }
+    }
+}
+
+#[tokio::main]
+async fn main() {
+    // Initialize tracing
+    tracing_subscriber::fmt()
+        .with_env_filter(
+            tracing_subscriber::EnvFilter::from_default_env()
+                .add_directive(tracing::Level::INFO.into()),
+        )
+        .init();
+
+    let app = Router::new()
+        .route("/v0/agents", post(handle_agent_publish))
+        .fallback(|req: axum::http::Request<axum::body::Body>| async move {
+            warn!("Unhandled request: {} {}", req.method(), req.uri());
+            (StatusCode::NOT_FOUND, "Not Found")
+        });
+
+    let addr = SocketAddr::from(([0, 0, 0, 0], 3000));
+    info!("Mock Collector listening on http://{}", addr);
+    info!("Expecting POST requests at http://{}/v0/agents", addr);
+
+    let listener = tokio::net::TcpListener::bind(addr).await.unwrap();
+    axum::serve(listener, app).await.unwrap();
+}

src/chain/encode.rs

@@ -83,15 +83,12 @@ mod tests {
     use alloy::primitives::aliases::{U240, U48};
 
     use super::*;
-    use crate::logs::init_logs;
-
-    // This ensures metrics are initialized exactly once
+    // This ensures tracing is initialized exactly once for tests
     static INIT: Once = Once::new();
 
     fn setup() {
         INIT.call_once(|| {
-            // Initialize metrics for testing
-            init_logs();
+            let _ = tracing_subscriber::fmt().with_test_writer().try_init();
         });
     }
 

src/lib.rs

@@ -0,0 +1,6 @@
+//! Gas Agent library - shared types for the gas agent ecosystem.
+
+mod chain;
+mod types;
+
+pub use types::AgentPayload;

src/types.rs

@@ -12,6 +12,7 @@ use serde::{Deserialize, Serialize};
 use std::{fmt, str::FromStr};
 use strum_macros::{Display, EnumString};
 
+#[allow(dead_code)] // Used by binary
 #[derive(Debug, Clone, EnumString, Display, Deserialize, Serialize)]
 #[strum(serialize_all = "snake_case")]
 #[serde(rename_all = "snake_case")]
@@ -25,6 +26,7 @@ pub enum ModelKind {
     PendingFloor,
 }
 
+#[allow(dead_code)] // Used by binary
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(rename_all = "snake_case")]
 #[serde(from = "String")]
@@ -265,6 +267,7 @@ impl SystemNetworkKey {
         }
     }
 
+    #[allow(dead_code)] // Used by agent binary only
     pub fn to_block_time(&self) -> u64 {
         match self {
             SystemNetworkKey {