Merge pull request #292 from chainbound/nico/feat/sidecar-delegations

feat(sidecar): load delegations on startup and send them upon registration

bolt-sidecar/Cargo.toml

@@ -61,7 +61,7 @@ thiserror = "1.0"
 rand = "0.8.5"
 dotenvy = "0.15.7"
 regex = "1.10.5"
-# backtrace = "0.3.74"
+toml = "0.5"
 
 # tracing
 tracing = "0.1.40"

bolt-sidecar/Config.example.toml

@@ -0,0 +1,20 @@
+# ports
+port = 8000
+metrics_port = 3300
+
+# node urls
+execution_api_url = "http://localhost:8545"
+beacon_api_url = "http://localhost:5052"
+engine_api_url = "http://localhost:8551"
+
+# constraints options
+constraints_url = "http://localhost:3030"
+constraints_proxy_port = 18551
+
+# chain options
+chain = "kurtosis"
+slot_time = 2
+
+# signing options
+private_key = "0x359c156600e1f5715a58c9e09f17c8d04e7ee3a9f88b39f6e489ffca0148fabe"
+delegations_path = "./delegations.json"

bolt-sidecar/bin/sidecar.rs

@@ -1,15 +1,18 @@
-use bolt_sidecar::{telemetry::init_telemetry_stack, Opts, SidecarDriver};
 use clap::Parser;
 use eyre::{bail, Result};
 use tracing::info;
 
+use bolt_sidecar::{telemetry::init_telemetry_stack, Opts, SidecarDriver};
+
 #[tokio::main]
 async fn main() -> Result<()> {
-    let opts = Opts::parse();
+    let opts = if let Ok(config_path) = std::env::var("BOLT_SIDECAR_CONFIG_PATH") {
+        Opts::parse_from_toml(config_path.as_str())?
+    } else {
+        Opts::parse()
+    };
 
-    let metrics_port =
-        if !opts.telemetry.disable_metrics { Some(opts.telemetry.metrics_port) } else { None };
-    if let Err(err) = init_telemetry_stack(metrics_port) {
+    if let Err(err) = init_telemetry_stack(opts.telemetry.metrics_port()) {
         bail!("Failed to initialize telemetry stack: {:?}", err)
     }
 

bolt-sidecar/src/api/builder.rs

@@ -1,3 +1,5 @@
+use std::{sync::Arc, time::Duration};
+
 use axum::{
     body::{self, Body},
     extract::{Path, Request, State},
@@ -16,7 +18,6 @@ use ethereum_consensus::{
 use parking_lot::Mutex;
 use reqwest::Url;
 use serde::Deserialize;
-use std::{sync::Arc, time::Duration};
 use thiserror::Error;
 use tokio::net::TcpListener;
 use tracing::{debug, error, info, warn};
@@ -26,8 +27,9 @@ use super::spec::{
     STATUS_PATH,
 };
 use crate::{
+    builder::payload_fetcher::PayloadFetcher,
     client::constraints_client::ConstraintsClient,
-    primitives::{GetPayloadResponse, PayloadFetcher, SignedBuilderBid},
+    primitives::{GetPayloadResponse, SignedBuilderBid},
     telemetry::ApiMetrics,
 };
 

bolt-sidecar/src/api/commitments/handlers.rs

@@ -12,8 +12,9 @@ use serde_json::Value;
 use tracing::{debug, error, info, instrument};
 
 use crate::{
-    commitments::headers::auth_from_headers, common::CARGO_PKG_VERSION,
-    primitives::InclusionRequest,
+    commitments::headers::auth_from_headers,
+    common::CARGO_PKG_VERSION,
+    primitives::{commitment::SignatureError, InclusionRequest},
 };
 
 use super::{
@@ -70,7 +71,7 @@ pub async fn rpc_entrypoint(
                     "Recovered signer does not match the provided signer"
                 );
 
-                return Err(Error::InvalidSignature(crate::primitives::SignatureError));
+                return Err(Error::InvalidSignature(SignatureError));
             }
 
             // Set the request signer

bolt-sidecar/src/api/commitments/headers.rs

@@ -3,6 +3,8 @@ use std::str::FromStr;
 use alloy::primitives::{Address, Signature};
 use axum::http::HeaderMap;
 
+use crate::primitives::commitment::SignatureError;
+
 use super::spec::{Error, SIGNATURE_HEADER};
 
 /// Extracts the signature ([SIGNATURE_HEADER]) from the HTTP headers.
@@ -19,8 +21,7 @@ pub fn auth_from_headers(headers: &HeaderMap) -> Result<(Address, Signature), Er
     let address = Address::from_str(address).map_err(|_| Error::MalformedHeader)?;
 
     let sig = split.next().ok_or(Error::MalformedHeader)?;
-    let sig = Signature::from_str(sig)
-        .map_err(|_| Error::InvalidSignature(crate::primitives::SignatureError))?;
+    let sig = Signature::from_str(sig).map_err(|_| Error::InvalidSignature(SignatureError))?;
 
     Ok((address, sig))
 }

bolt-sidecar/src/api/commitments/spec.rs

@@ -40,7 +40,7 @@ pub enum Error {
     NoSignature,
     /// Invalid signature.
     #[error(transparent)]
-    InvalidSignature(#[from] crate::primitives::SignatureError),
+    InvalidSignature(#[from] crate::primitives::commitment::SignatureError),
     /// Malformed authentication header.
     #[error("Malformed authentication header")]
     MalformedHeader,

bolt-sidecar/src/api/spec.rs

@@ -172,8 +172,8 @@ pub trait ConstraintsApi: BuilderApi {
     ) -> Result<VersionedValue<SignedBuilderBid>, BuilderApiError>;
 
     /// Implements: <https://chainbound.github.io/bolt-docs/api/builder#delegate>
-    async fn delegate(&self, signed_data: SignedDelegation) -> Result<(), BuilderApiError>;
+    async fn delegate(&self, signed_data: &[SignedDelegation]) -> Result<(), BuilderApiError>;
 
     /// Implements: <https://chainbound.github.io/bolt-docs/api/builder#revoke>
-    async fn revoke(&self, signed_data: SignedRevocation) -> Result<(), BuilderApiError>;
+    async fn revoke(&self, signed_data: &[SignedRevocation]) -> Result<(), BuilderApiError>;
 }

bolt-sidecar/src/builder/mod.rs

@@ -5,8 +5,6 @@ use ethereum_consensus::{
     deneb::mainnet::ExecutionPayloadHeader,
     ssz::prelude::{List, MerkleizationError},
 };
-use payload_builder::FallbackPayloadBuilder;
-use signature::sign_builder_message;
 
 use crate::{
     common::BlsSecretKeyWrapper,
@@ -23,16 +21,21 @@ pub use template::BlockTemplate;
 
 /// Builder payload signing utilities
 pub mod signature;
+use signature::sign_builder_message;
+
+/// Fallback Payload builder agent that leverages the engine API's
+/// `engine_newPayloadV3` response error to produce a valid payload.
+pub mod payload_builder;
+use payload_builder::FallbackPayloadBuilder;
+
+/// Interface for fetching payloads from the beacon node.
+pub mod payload_fetcher;
 
 /// Compatibility types and utilities between Alloy, Reth,
 /// Ethereum-consensus and other crates.
 #[doc(hidden)]
 mod compat;
 
-/// Fallback Payload builder agent that leverages the engine API's
-/// `engine_newPayloadV3` response error to produce a valid payload.
-pub mod payload_builder;
-
 #[derive(Debug, thiserror::Error)]
 #[non_exhaustive]
 #[allow(missing_docs)]

bolt-sidecar/src/builder/payload_fetcher.rs

@@ -0,0 +1,57 @@
+use tokio::sync::{mpsc, oneshot};
+use tracing::error;
+
+use crate::primitives::{FetchPayloadRequest, PayloadAndBid};
+
+/// A local payload fetcher that sends requests to a channel
+/// and waits for a response on a oneshot channel.
+#[derive(Debug, Clone)]
+pub struct LocalPayloadFetcher {
+    tx: mpsc::Sender<FetchPayloadRequest>,
+}
+
+impl LocalPayloadFetcher {
+    /// Create a new `LocalPayloadFetcher` with the given channel to send fetch requests.
+    pub fn new(tx: mpsc::Sender<FetchPayloadRequest>) -> Self {
+        Self { tx }
+    }
+}
+
+#[async_trait::async_trait]
+impl PayloadFetcher for LocalPayloadFetcher {
+    async fn fetch_payload(&self, slot: u64) -> Option<PayloadAndBid> {
+        let (response_tx, response_rx) = oneshot::channel();
+
+        let fetch_params = FetchPayloadRequest { response_tx, slot };
+        self.tx.send(fetch_params).await.ok()?;
+
+        match response_rx.await {
+            Ok(res) => res,
+            Err(e) => {
+                error!(err = ?e, "Failed to fetch payload");
+                None
+            }
+        }
+    }
+}
+
+/// Interface for fetching payloads for the builder.
+#[async_trait::async_trait]
+pub trait PayloadFetcher {
+    /// Fetch a payload for the given slot.
+    async fn fetch_payload(&self, slot: u64) -> Option<PayloadAndBid>;
+}
+
+/// A payload fetcher that does nothing, used for testing.
+#[derive(Debug)]
+#[cfg(test)]
+pub struct NoopPayloadFetcher;
+
+#[cfg(test)]
+#[async_trait::async_trait]
+impl PayloadFetcher for NoopPayloadFetcher {
+    async fn fetch_payload(&self, slot: u64) -> Option<PayloadAndBid> {
+        tracing::info!(slot, "Fetch payload called");
+        None
+    }
+}

bolt-sidecar/src/client/constraints_client.rs

@@ -2,10 +2,13 @@
 //! The Bolt sidecar's main purpose is to sit between the beacon node and Constraints client,
 //! so most requests are simply proxied to its API.
 
+use std::collections::HashSet;
+
 use axum::http::StatusCode;
 use beacon_api_client::VersionedValue;
 use ethereum_consensus::{
-    builder::SignedValidatorRegistration, deneb::mainnet::SignedBlindedBeaconBlock, Fork,
+    builder::SignedValidatorRegistration, crypto::PublicKey as BlsPublicKey,
+    deneb::mainnet::SignedBlindedBeaconBlock, Fork,
 };
 use reqwest::Url;
 use tracing::error;
@@ -30,6 +33,7 @@ use crate::{
 pub struct ConstraintsClient {
     url: Url,
     client: reqwest::Client,
+    delegations: Vec<SignedDelegation>,
 }
 
 impl ConstraintsClient {
@@ -38,9 +42,24 @@ impl ConstraintsClient {
         Self {
             url: url.into(),
             client: reqwest::ClientBuilder::new().user_agent("bolt-sidecar").build().unwrap(),
+            delegations: Vec::new(),
         }
     }
 
+    /// Adds a list of delegations to the client.
+    pub fn add_delegations(&mut self, delegations: Vec<SignedDelegation>) {
+        self.delegations.extend(delegations);
+    }
+
+    /// Finds all delegations for the given public key.
+    pub fn find_delegatees(&self, pubkey: &BlsPublicKey) -> HashSet<BlsPublicKey> {
+        self.delegations
+            .iter()
+            .filter(|d| d.message.delegatee_pubkey == *pubkey)
+            .map(|d| d.message.delegatee_pubkey.clone())
+            .collect::<HashSet<_>>()
+    }
+
     fn endpoint(&self, path: &str) -> Url {
         self.url.join(path).unwrap_or_else(|e| {
             error!(err = ?e, "Failed to join path: {} with url: {}", path, self.url);
@@ -80,6 +99,13 @@ impl BuilderApi for ConstraintsClient {
             return Err(BuilderApiError::FailedRegisteringValidators(error));
         }
 
+        // If there are any delegations, propagate them to the relay
+        if self.delegations.is_empty() {
+            return Ok(());
+        } else if let Err(err) = self.delegate(&self.delegations).await {
+            error!(?err, "Failed to propagate delegations during validator registration");
+        }
+
         Ok(())
     }
 
@@ -190,12 +216,12 @@ impl ConstraintsApi for ConstraintsClient {
         Ok(header)
     }
 
-    async fn delegate(&self, signed_data: SignedDelegation) -> Result<(), BuilderApiError> {
+    async fn delegate(&self, signed_data: &[SignedDelegation]) -> Result<(), BuilderApiError> {
         let response = self
             .client
             .post(self.endpoint(DELEGATE_PATH))
             .header("content-type", "application/json")
-            .body(serde_json::to_string(&signed_data)?)
+            .body(serde_json::to_string(signed_data)?)
             .send()
             .await?;
 
@@ -207,12 +233,12 @@ impl ConstraintsApi for ConstraintsClient {
         Ok(())
     }
 
-    async fn revoke(&self, signed_data: SignedRevocation) -> Result<(), BuilderApiError> {
+    async fn revoke(&self, signed_data: &[SignedRevocation]) -> Result<(), BuilderApiError> {
         let response = self
             .client
             .post(self.endpoint(REVOKE_PATH))
             .header("content-type", "application/json")
-            .body(serde_json::to_string(&signed_data)?)
+            .body(serde_json::to_string(signed_data)?)
             .send()
             .await?;
 

bolt-sidecar/src/client/test_util/mod.rs

@@ -98,13 +98,13 @@ impl ConstraintsApi for MockConstraintsClient {
         Ok(bid)
     }
 
-    async fn delegate(&self, signed_data: SignedDelegation) -> Result<(), BuilderApiError> {
+    async fn delegate(&self, signed_data: &[SignedDelegation]) -> Result<(), BuilderApiError> {
         Err(BuilderApiError::Generic(
             "MockConstraintsClient does not support delegating".to_string(),
         ))
     }
 
-    async fn revoke(&self, signed_data: SignedRevocation) -> Result<(), BuilderApiError> {
+    async fn revoke(&self, signed_data: &[SignedRevocation]) -> Result<(), BuilderApiError> {
         Err(BuilderApiError::Generic("MockConstraintsClient does not support revoking".to_string()))
     }
 }

bolt-sidecar/src/common.rs

@@ -9,6 +9,7 @@ use alloy::primitives::U256;
 use blst::min_pk::SecretKey;
 use rand::{Rng, RngCore};
 use reth_primitives::PooledTransactionsElement;
+use serde::{Deserialize, Deserializer};
 
 use crate::{
     primitives::{AccountState, TransactionExt},
@@ -107,6 +108,16 @@ impl BlsSecretKeyWrapper {
     }
 }
 
+impl<'de> Deserialize<'de> for BlsSecretKeyWrapper {
+    fn deserialize<D>(deserializer: D) -> Result<BlsSecretKeyWrapper, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let sk = String::deserialize(deserializer)?;
+        Ok(BlsSecretKeyWrapper::from(sk.as_str()))
+    }
+}
+
 impl From<&str> for BlsSecretKeyWrapper {
     fn from(sk: &str) -> Self {
         let hex_sk = sk.strip_prefix("0x").unwrap_or(sk);
@@ -158,6 +169,16 @@ impl From<&str> for JwtSecretConfig {
     }
 }
 
+impl<'de> Deserialize<'de> for JwtSecretConfig {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let jwt = String::deserialize(deserializer)?;
+        Ok(Self::from(jwt.as_str()))
+    }
+}
+
 impl Deref for JwtSecretConfig {
     type Target = str;
     fn deref(&self) -> &Self::Target {