adds beacon api

CONTEXT.md

@@ -27,3 +27,12 @@ payloads.
 A transport-free library living inside a tile that owns the loop. Hosted
 crates are hardcoded into their tile, not plugins.
 _Avoid_: plugin, sub-tile, service.
+
+**Beacon API**:
+The standard Ethereum REST API a beacon node serves; validator clients are
+the primary consumers. Served by the `beacon_api` hosted crate.
+
+**Engine API**:
+The standard JSON-RPC protocol between a beacon node and its execution
+client. Called by the `engine_api` hosted crate.
+_Avoid_: bare "engine" (ambiguous with the execution client itself).

Cargo.toml

@@ -1,5 +1,7 @@
 [workspace]
 members = [
+  "crates/application_boundary",
+  "crates/beacon_api",
   "crates/beacon_state/data",
   "crates/beacon_state/tile",
   "crates/bin",
@@ -11,7 +13,8 @@ members = [
   "crates/discovery",
   "crates/e2e",
   "crates/gossip",
-  "crates/engine",
+  "crates/httpcore",
+  "crates/engine_api",
   "crates/metrics",
   "crates/network",
   "crates/peer",
@@ -66,6 +69,8 @@ inherits = "dev"
 opt-level = 3
 
 [workspace.dependencies]
+silver_application_boundary = { path = "crates/application_boundary" }
+silver_beacon_api = { path = "crates/beacon_api" }
 silver_beacon_state = { path = "crates/beacon_state/tile" }
 silver_beacon_state_data = { path = "crates/beacon_state/data" }
 silver_chain_spec = { path = "crates/config/chain_spec" }
@@ -77,10 +82,11 @@ silver_ssz = { path = "crates/ssz" }
 silver_control = { path = "crates/control" }
 silver_discovery = {path = "crates/discovery" }
 silver_gossip = {path = "crates/gossip" }
+silver_httpcore = { path = "crates/httpcore" }
 silver_network = {path = "crates/network" }
 silver_peer = {path = "crates/peer" }
 silver_storage = { path = "crates/storage" }
-silver_engine = { path = "crates/engine"}
+silver_engine_api = { path = "crates/engine_api" }
 flux = { git = "https://github.com/gattaca-com/flux", rev = "b5fbdf6f3e52feb785a527d5c3bba90fee2a56e4"}
 flux-utils = { git = "https://github.com/gattaca-com/flux", rev = "b5fbdf6f3e52feb785a527d5c3bba90fee2a56e4", features = ["bytes"]}
 flux-profiler = { git = "https://github.com/gattaca-com/flux", rev = "b5fbdf6f3e52feb785a527d5c3bba90fee2a56e4"}

crates/application_boundary/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "silver_application_boundary"
+edition.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[dependencies]
+flux.workspace = true
+silver_beacon_api.workspace = true
+silver_beacon_state_data.workspace = true
+silver_common.workspace = true
+silver_config.workspace = true
+silver_engine_api.workspace = true
+silver_httpcore.workspace = true
+silver_peer.workspace = true
+
+[dev-dependencies]
+hex.workspace = true
+serde_json.workspace = true
+silver_engine_api = { workspace = true, features = ["test-el"] }
+tempfile = "3"
+
+[lints]
+workspace = true

crates/application_boundary/src/lib.rs

@@ -0,0 +1,121 @@
+use std::time::Duration;
+
+use flux::{spine::SpineAdapter, tile::Tile};
+use silver_beacon_api::{BeaconApi, ChainHead, PeerCounts, SlotStatus};
+use silver_beacon_state_data::{BeaconStateReader, SpecConfig};
+use silver_common::{
+    BeaconStateEvent, Enr, Identify, Keypair, SilverSpine, SyncUpdate, TProducer, TRandomAccess,
+    ssz_view::StatusView,
+};
+use silver_config::EngineConfig;
+use silver_engine_api::EngineApi;
+use silver_httpcore::{Bind, Readiness, TokenRange};
+use silver_peer::PeerCounters;
+
+/// A tenant added here takes the next share of a raised `TENANTS`, which keeps
+/// every share disjoint without a base to compute.
+const TENANTS: usize = 2;
+const BEACON_TOKENS: TokenRange = TokenRange::share(0, TENANTS);
+const ENGINE_TOKENS: TokenRange = TokenRange::share(1, TENANTS);
+
+pub struct ApplicationBoundaryTile {
+    readiness: Readiness,
+    pub beacon: BeaconApi,
+    engine: EngineApi,
+}
+
+impl Tile<SilverSpine> for ApplicationBoundaryTile {
+    fn loop_body(&mut self, adapter: &mut SpineAdapter<SilverSpine>) {
+        self.engine.intake(adapter);
+        self.readiness.wait(Duration::ZERO);
+        self.engine.spin(adapter, self.readiness.events());
+        self.refresh_node_status(adapter);
+        if self.beacon.pump(self.readiness.events()) {
+            adapter.mark_work();
+        }
+    }
+}
+
+impl ApplicationBoundaryTile {
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        binds: &[Bind],
+        max_connections: usize,
+        idle_timeout: Duration,
+        keypair: &Keypair,
+        local_enr: Enr,
+        identify: &Identify,
+        spec: &SpecConfig,
+        state: BeaconStateReader,
+        engine_config: EngineConfig,
+        gossip_consumer: TRandomAccess,
+        rpc_consumer: TRandomAccess,
+        resp_producer: TProducer,
+    ) -> Self {
+        // A batch too small for every socket the tile can register leaves the
+        // rest of a busy iteration's readiness for the next one.
+        let sockets =
+            binds.len() + max_connections + EngineApi::max_sockets(engine_config.max_connections);
+
+        let readiness = Readiness::new(sockets);
+        let beacon = BeaconApi::new(
+            readiness.registry(),
+            BEACON_TOKENS,
+            binds,
+            max_connections,
+            idle_timeout,
+            keypair,
+            local_enr,
+            identify,
+            spec,
+            state,
+        );
+        let engine = EngineApi::new(
+            readiness.registry(),
+            ENGINE_TOKENS,
+            engine_config,
+            gossip_consumer,
+            rpc_consumer,
+            resp_producer,
+        );
+        Self { readiness, beacon, engine }
+    }
+
+    fn refresh_node_status(&mut self, adapter: &mut SpineAdapter<SilverSpine>) {
+        let status = self.beacon.node_status_mut();
+
+        // Consumed every iteration, and never behind the engine's capacity
+        // gate: a consumer's first `consume` jumps its cursor to the
+        // producer's write head, so a queue left unread while the pool is
+        // saturated loses everything published in the meantime.
+        adapter.consume(|event: BeaconStateEvent, _| {
+            if let BeaconStateEvent::Status {
+                ssz,
+                latest_block_slot,
+                wall_slot,
+                head_optimistic,
+                ..
+            } = event
+            {
+                status.slots = Some(SlotStatus {
+                    latest_block_slot,
+                    head: ChainHead {
+                        root: *StatusView::head_root(&ssz),
+                        slot: StatusView::head_slot(&ssz),
+                    },
+                    wall_slot,
+                    head_optimistic,
+                });
+            }
+        });
+        adapter.consume(|update: SyncUpdate, _| {
+            status.syncing = !matches!(update, SyncUpdate::Following);
+        });
+
+        status.el = self.engine.sync_status();
+        status.peers = PeerCounts {
+            connected: PeerCounters::PeersConnected.get(),
+            connecting: PeerCounters::PeersConnecting.get(),
+        };
+    }
+}