error cleanup/refactor

mev-boost-rs/src/relay_mux.rs

@@ -10,7 +10,7 @@ use mev_rs::{
         AuctionRequest, ExecutionPayload, SignedBlindedBeaconBlock, SignedBuilderBid,
         SignedValidatorRegistration,
     },
-    BlindedBlockProvider, Error,
+    BlindedBlockProvider, BoostError, Error,
 };
 use parking_lot::Mutex;
 use rand::prelude::*;
@@ -41,10 +41,11 @@ fn validate_bid(
 ) -> Result<(), Error> {
     let bid_public_key = &bid.message.public_key;
     if bid_public_key != public_key {
-        return Err(Error::BidPublicKeyMismatch {
+        return Err(BoostError::BidPublicKeyMismatch {
             bid: bid_public_key.clone(),
             relay: public_key.clone(),
-        })
+        }
+        .into())
     }
     Ok(bid.verify_signature(context)?)
 }
@@ -139,7 +140,7 @@ impl BlindedBlockProvider for RelayMux {
         }
 
         if num_failures == self.relays.len() {
-            Err(Error::CouldNotRegister)
+            Err(BoostError::CouldNotRegister.into())
         } else {
             let mut state = self.state.lock();
             state.current_epoch_registration_count += registrations.len();
@@ -189,7 +190,7 @@ impl BlindedBlockProvider for RelayMux {
             .await;
 
         if bids.is_empty() {
-            return Err(Error::NoBids)
+            return Err(Error::NoBidPrepared(auction_request.clone()))
         }
 
         // TODO: change `value` so it does the copy internally
@@ -239,7 +240,11 @@ impl BlindedBlockProvider for RelayMux {
         let (auction_request, relays) = {
             let mut state = self.state.lock();
             let key = bid_key_from(signed_block, &state.latest_pubkey);
-            let relays = state.outstanding_bids.remove(&key).ok_or(Error::MissingOpenBid)?;
+            // TODO: do not `remove` so this endpoint can be retried
+            let relays = state
+                .outstanding_bids
+                .remove(&key)
+                .ok_or_else::<Error, _>(|| BoostError::MissingOpenBid.into())?;
             (key, relays)
         };
 
@@ -274,7 +279,7 @@ impl BlindedBlockProvider for RelayMux {
             }
         }
 
-        Err(Error::MissingPayload(expected_block_hash.clone()))
+        Err(BoostError::MissingPayload(expected_block_hash.clone()).into())
     }
 }
 

mev-relay-rs/src/relay.rs

@@ -18,7 +18,8 @@ use mev_rs::{
         ProposerSchedule, SignedBidSubmission, SignedBlindedBeaconBlock, SignedBuilderBid,
         SignedValidatorRegistration,
     },
-    BlindedBlockProvider, BlindedBlockRelayer, Error, ProposerScheduler, ValidatorRegistry,
+    BlindedBlockProvider, BlindedBlockRelayer, Error, ProposerScheduler, RelayError,
+    ValidatorRegistry,
 };
 use parking_lot::Mutex;
 use std::{
@@ -42,27 +43,27 @@ fn to_header(execution_payload: &mut ExecutionPayload) -> Result<ExecutionPayloa
 fn validate_header_equality(
     local_header: &ExecutionPayloadHeader,
     provided_header: ExecutionPayloadHeaderRef<'_>,
-) -> Result<(), Error> {
+) -> Result<(), RelayError> {
     match local_header {
         ExecutionPayloadHeader::Bellatrix(local_header) => {
             let provided_header =
-                provided_header.bellatrix().ok_or(Error::InvalidExecutionPayloadInBlock)?;
+                provided_header.bellatrix().ok_or(RelayError::InvalidExecutionPayloadInBlock)?;
             if local_header != provided_header {
-                return Err(Error::InvalidExecutionPayloadInBlock);
+                return Err(RelayError::InvalidExecutionPayloadInBlock);
             }
         }
         ExecutionPayloadHeader::Capella(local_header) => {
             let provided_header =
-                provided_header.capella().ok_or(Error::InvalidExecutionPayloadInBlock)?;
+                provided_header.capella().ok_or(RelayError::InvalidExecutionPayloadInBlock)?;
             if local_header != provided_header {
-                return Err(Error::InvalidExecutionPayloadInBlock);
+                return Err(RelayError::InvalidExecutionPayloadInBlock);
             }
         }
         ExecutionPayloadHeader::Deneb(local_header) => {
             let provided_header =
-                provided_header.deneb().ok_or(Error::InvalidExecutionPayloadInBlock)?;
+                provided_header.deneb().ok_or(RelayError::InvalidExecutionPayloadInBlock)?;
             if local_header != provided_header {
-                return Err(Error::InvalidExecutionPayloadInBlock);
+                return Err(RelayError::InvalidExecutionPayloadInBlock);
             }
         }
     }
@@ -150,10 +151,10 @@ impl Relay {
 
     // TODO: build tip context and support reorgs...
     pub fn on_payload_attributes(&self, event: PayloadAttributesEvent) -> Result<(), Error> {
-        let proposer_public_key = self
-            .validator_registry
-            .get_public_key(event.proposer_index)
-            .ok_or_else(|| Error::UnknownValidatorIndex(event.proposer_index))?;
+        let proposer_public_key =
+            self.validator_registry.get_public_key(event.proposer_index).ok_or_else::<Error, _>(
+                || RelayError::UnknownValidatorIndex(event.proposer_index).into(),
+            )?;
         let mut state = self.state.lock();
         state.head = AuctionRequest {
             slot: event.proposal_slot,
@@ -172,16 +173,16 @@ impl Relay {
         if self.builder_registry.contains(builder_public_key) {
             Ok(())
         } else {
-            Err(Error::BuilderNotRegistered(builder_public_key.clone()))
+            Err(RelayError::BuilderNotRegistered(builder_public_key.clone()).into())
         }
     }
 
-    fn validate_auction_request(&self, auction_request: &AuctionRequest) -> Result<(), Error> {
+    fn validate_auction_request(&self, auction_request: &AuctionRequest) -> Result<(), RelayError> {
         let state = self.state.lock();
         if &state.head == auction_request {
             Ok(())
         } else {
-            Err(Error::InvalidAuctionRequest {
+            Err(RelayError::InvalidAuctionRequest {
                 provided: auction_request.clone(),
                 expected: state.head.clone(),
             })
@@ -202,16 +203,16 @@ impl Relay {
         &self,
         bid_trace: &BidTrace,
         execution_payload: &ExecutionPayload,
-    ) -> Result<(), Error> {
+    ) -> Result<(), RelayError> {
         let proposer_public_key = &bid_trace.proposer_public_key;
         let signed_registration = self
             .validator_registry
             .get_signed_registration(proposer_public_key)
-            .ok_or_else(|| Error::ValidatorNotRegistered(proposer_public_key.clone()))?;
+            .ok_or_else(|| RelayError::ValidatorNotRegistered(proposer_public_key.clone()))?;
 
         if bid_trace.proposer_fee_recipient != signed_registration.message.fee_recipient {
             let fee_recipient = &signed_registration.message.fee_recipient;
-            return Err(Error::InvalidFeeRecipient(
+            return Err(RelayError::InvalidFeeRecipient(
                 proposer_public_key.clone(),
                 fee_recipient.clone(),
             ))
@@ -228,22 +229,25 @@ impl Relay {
         // }
 
         if bid_trace.gas_limit != execution_payload.gas_limit() {
-            return Err(Error::InvalidGasLimit(bid_trace.gas_limit, execution_payload.gas_limit()))
+            return Err(RelayError::InvalidGasLimit(
+                bid_trace.gas_limit,
+                execution_payload.gas_limit(),
+            ))
         }
 
         if bid_trace.gas_used != execution_payload.gas_used() {
-            return Err(Error::InvalidGasUsed(bid_trace.gas_used, execution_payload.gas_used()))
+            return Err(RelayError::InvalidGasUsed(bid_trace.gas_used, execution_payload.gas_used()))
         }
 
         if &bid_trace.parent_hash != execution_payload.parent_hash() {
-            return Err(Error::InvalidParentHash(
+            return Err(RelayError::InvalidParentHash(
                 bid_trace.parent_hash.clone(),
                 execution_payload.parent_hash().clone(),
             ))
         }
 
         if &bid_trace.block_hash != execution_payload.block_hash() {
-            return Err(Error::InvalidBlockHash(
+            return Err(RelayError::InvalidBlockHash(
                 bid_trace.block_hash.clone(),
                 execution_payload.block_hash().clone(),
             ))
@@ -315,15 +319,15 @@ impl BlindedBlockProvider for Relay {
             let public_key = self
                 .validator_registry
                 .get_public_key(proposer_index)
-                .ok_or(Error::UnknownValidatorIndex(proposer_index))?;
+                .ok_or(RelayError::UnknownValidatorIndex(proposer_index))?;
             AuctionRequest { slot, parent_hash, public_key }
         };
 
         self.validate_auction_request(&auction_request)?;
 
         let auction_context = self
             .get_auction_context(&auction_request)
-            .ok_or_else(|| Error::MissingAuction(auction_request.clone()))?;
+            .ok_or_else(|| RelayError::MissingAuction(auction_request.clone()))?;
 
         {
             let block = signed_block.message();
@@ -332,7 +336,7 @@ impl BlindedBlockProvider for Relay {
             let local_header = &auction_context.signed_builder_bid.message.header;
             if let Err(err) = validate_header_equality(local_header, execution_payload_header) {
                 warn!(%err, %auction_request, "invalid incoming signed blinded beacon block");
-                return Err(Error::InvalidSignedBlindedBeaconBlock)
+                return Err(RelayError::InvalidSignedBlindedBeaconBlock.into())
             }
         }
 
@@ -347,7 +351,7 @@ impl BlindedBlockProvider for Relay {
             let block_root =
                 signed_block.message_mut().hash_tree_root().map_err(ConsensusError::from)?;
             warn!(%err, %auction_request, %block_root, "block failed beacon node validation");
-            Err(Error::InvalidSignedBlindedBeaconBlock)
+            Err(RelayError::InvalidSignedBlindedBeaconBlock.into())
         } else {
             let local_payload = &auction_context.execution_payload;
             Ok(local_payload.clone())

mev-rs/src/error.rs

@@ -1,38 +1,33 @@
 use crate::types::AuctionRequest;
 use beacon_api_client::Error as ApiError;
 use ethereum_consensus::{
-    primitives::{BlsPublicKey, ExecutionAddress, Hash32, Slot, ValidatorIndex},
+    primitives::{BlsPublicKey, ExecutionAddress, Hash32, ValidatorIndex},
     Error as ConsensusError,
 };
 use thiserror::Error;
 
 #[derive(Debug, Error)]
-pub enum Error {
+pub enum BoostError {
     #[error("bid public key {bid} does not match relay public key {relay}")]
     BidPublicKeyMismatch { bid: BlsPublicKey, relay: BlsPublicKey },
-    #[error("no valid bids returned for proposal")]
-    NoBids,
     #[error("could not find relay with outstanding bid to accept")]
     MissingOpenBid,
-    #[error("could not find proposer for slot {0}")]
-    MissingProposer(Slot),
     #[error("could not register with any relay")]
     CouldNotRegister,
-    // #[error("no preferences found for validator with public key {0:?}")]
-    // MissingPreferences(BlsPublicKey),
     #[error("no payload returned for opened bid with block hash {0:?}")]
     MissingPayload(Hash32),
-    #[error("data for an unexpected fork was provided")]
-    InvalidFork,
+}
 
+#[derive(Debug, Error)]
+pub enum RelayError {
     #[error("received auction request for {provided} but expecting request at {expected}")]
     InvalidAuctionRequest { expected: AuctionRequest, provided: AuctionRequest },
     #[error("execution payload does not match the provided header")]
     InvalidExecutionPayloadInBlock,
     #[error("validator {0:?} does not have registered fee recipient {1:?}")]
     InvalidFeeRecipient(BlsPublicKey, ExecutionAddress),
-    #[error("validator {0:?} does not have (adjusted) registered gas limit {1}")]
-    InvalidGasLimitForProposer(BlsPublicKey, u64),
+    // #[error("validator {0:?} does not have (adjusted) registered gas limit {1}")]
+    // InvalidGasLimitForProposer(BlsPublicKey, u64),
     #[error("bid trace declares gas limit of {0:?} but execution payload has {1:?}")]
     InvalidGasLimit(u64, u64),
     #[error("bid trace declares gas usage of {0} but execution payload uses {1}")]
@@ -41,9 +36,6 @@ pub enum Error {
     InvalidParentHash(Hash32, Hash32),
     #[error("bid trace declares block hash of {0:?} but execution payload has {1:?}")]
     InvalidBlockHash(Hash32, Hash32),
-    #[error("no bid prepared for request {0}")]
-    NoBidPrepared(AuctionRequest),
-
     #[error("missing auction for {0}")]
     MissingAuction(AuctionRequest),
     #[error("signed blinded beacon block is invalid or equivocated")]
@@ -54,14 +46,22 @@ pub enum Error {
     UnknownValidatorIndex(ValidatorIndex),
     #[error("builder with public key {0:?} is not currently registered")]
     BuilderNotRegistered(BlsPublicKey),
+}
 
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("no bid prepared for request {0}")]
+    NoBidPrepared(AuctionRequest),
     #[error(transparent)]
     ValidatorRegistry(#[from] crate::validator_registry::Error),
     #[error(transparent)]
     ProposerScheduler(#[from] crate::proposer_scheduler::Error),
     #[error("validator registration errors: {0:?}")]
     RegistrationErrors(Vec<crate::validator_registry::Error>),
-
+    #[error(transparent)]
+    Boost(#[from] BoostError),
+    #[error(transparent)]
+    Relay(#[from] RelayError),
     #[error(transparent)]
     Consensus(#[from] ConsensusError),
     #[error(transparent)]

mev-rs/src/lib.rs

@@ -14,7 +14,7 @@ pub use blinded_block_provider::BlindedBlockProvider;
 pub use blinded_block_relayer::BlindedBlockRelayer;
 
 pub use block_validation::*;
-pub use error::Error;
+pub use error::*;
 pub use proposer_scheduler::ProposerScheduler;
 pub use relay::{Relay, RelayEndpoint};
 pub use validator_registry::ValidatorRegistry;