chore(sidecar): extra private fields on constraint

bolt-sidecar/bin/sidecar.rs

@@ -78,14 +78,17 @@ async fn main() -> eyre::Result<()> {
                     }
                 };
 
-                if let Err(e) = execution_state
+                let sender = match execution_state
                     .check_commitment_validity(&request)
-                    .await
+                .await
                 {
-                    tracing::error!("Failed to commit request: {:?}", e);
-                    let _ = response_tx.send(Err(ApiError::Custom(e.to_string())));
-                    continue;
-                }
+                    Ok(sender) => { sender },
+                    Err(e) => {
+                        tracing::error!("Failed to commit request: {:?}", e);
+                        let _ = response_tx.send(Err(ApiError::Custom(e.to_string())));
+                        continue;
+                    }
+                };
 
                 // TODO: match when we have more request types
                 let CommitmentRequest::Inclusion(request) = request;
@@ -97,7 +100,7 @@ async fn main() -> eyre::Result<()> {
                 // TODO: review all this `clone` usage
 
                 // parse the request into constraints and sign them with the sidecar signer
-                let message = ConstraintsMessage::build(validator_index, request.slot, request.clone());
+                let message = ConstraintsMessage::build(validator_index, request.slot, request.clone(), sender);
                 let signature = signer.sign(&message.digest())?.to_string();
                 let signed_constraints = SignedConstraints { message, signature };
 

bolt-sidecar/src/primitives/constraint.rs

@@ -1,4 +1,5 @@
-use alloy_primitives::keccak256;
+use alloy_primitives::{keccak256, Address};
+use reth_primitives::TransactionSigned;
 use secp256k1::Message;
 use serde::{Deserialize, Serialize};
 
@@ -50,8 +51,13 @@ pub struct ConstraintsMessage {
 
 impl ConstraintsMessage {
     /// Builds a constraints message from an inclusion request and metadata
-    pub fn build(validator_index: u64, slot: u64, request: InclusionRequest) -> Self {
-        let constraints = vec![Constraint::from_inclusion_request(request, None)];
+    pub fn build(
+        validator_index: u64,
+        slot: u64,
+        request: InclusionRequest,
+        sender: Address,
+    ) -> Self {
+        let constraints = vec![Constraint::from_inclusion_request(request, None, sender)];
         Self {
             validator_index,
             slot,
@@ -83,17 +89,29 @@ pub struct Constraint {
     pub tx: String,
     /// The optional index at which the transaction needs to be included in the block
     pub index: Option<u64>,
+    /// The decoded transaction for internal use
+    #[serde(skip)]
+    pub(crate) tx_decoded: TransactionSigned,
+    /// The ec-recovered address of the transaction sender for internal use
+    #[serde(skip)]
+    pub(crate) sender: Address,
 }
 
 impl Constraint {
     /// Builds a constraint from an inclusion request and an optional index
-    pub fn from_inclusion_request(req: InclusionRequest, index: Option<u64>) -> Self {
+    pub fn from_inclusion_request(
+        req: InclusionRequest,
+        index: Option<u64>,
+        sender: Address,
+    ) -> Self {
         let mut encoded_tx = Vec::new();
         req.tx.encode_enveloped(&mut encoded_tx);
 
         Self {
             tx: format!("0x{}", hex::encode(encoded_tx)),
             index,
+            tx_decoded: req.tx,
+            sender,
         }
     }
 

bolt-sidecar/src/state/execution.rs

@@ -123,7 +123,7 @@ impl<C: StateFetcher> ExecutionState<C> {
     pub async fn check_commitment_validity(
         &mut self,
         request: &CommitmentRequest,
-    ) -> Result<(), ValidationError> {
+    ) -> Result<Address, ValidationError> {
         let CommitmentRequest::Inclusion(req) = request;
 
         // Check if there is room for more commitments
@@ -187,7 +187,7 @@ impl<C: StateFetcher> ExecutionState<C> {
             // TODO: check max_fee_per_blob_gas against the blob_base_fee
         }
 
-        Ok(())
+        Ok(sender)
     }
 
     /// Commits the transaction to the target block. Initializes a new block template