chore: replace std::sync::Mutex with parking_lot::Mutex

mev-boost-rs/Cargo.toml

@@ -16,6 +16,7 @@ async-trait = "0.1.53"
 url = { version = "2.2.2", default-features = false }
 serde = { version = "1.0", features = ["derive"] }
 thiserror = "1.0.30"
+parking_lot = "0.12.1"
 
 ethereum-consensus = { git = "https://github.com/ralexstokes/ethereum-consensus", rev = "a8110af76d97bf2bf27fb987a671808fcbdf1834" }
 beacon-api-client = { git = "https://github.com/ralexstokes/beacon-api-client", rev = "7d5d8dad1648f771573f42585ad8080a45b05689" }

mev-boost-rs/src/relay_mux.rs

@@ -10,11 +10,8 @@ use mev_build_rs::{
     BlindedBlockProviderClient as Relay, BlindedBlockProviderError, ExecutionPayload, Network,
     SignedBlindedBeaconBlock, SignedBuilderBid, SignedValidatorRegistration,
 };
-use std::{
-    collections::HashMap,
-    ops::Deref,
-    sync::{Arc, Mutex},
-};
+use parking_lot::Mutex;
+use std::{collections::HashMap, ops::Deref, sync::Arc};
 use thiserror::Error;
 
 // See note in the `mev-relay-rs::Relay` about this constant.
@@ -112,7 +109,7 @@ impl RelayMux {
         tokio::pin!(slots);
 
         while let Some(slot) = slots.next().await {
-            let mut state = self.state.lock().unwrap();
+            let mut state = self.state.lock();
             state
                 .outstanding_bids
                 .retain(|bid_request, _| bid_request.slot + PROPOSAL_TOLERANCE_DELAY >= slot);
@@ -191,11 +188,13 @@ impl BlindedBlockProvider for RelayMux {
             }
         }
 
-        let mut state = self.state.lock().unwrap();
-        // assume the next request to open a bid corresponds to the current request
-        // TODO consider if the relay mux should have more knowledge about the proposal
-        state.latest_pubkey = bid_request.public_key.clone();
-        state.outstanding_bids.insert(bid_request.clone(), relay_indices);
+        {
+            let mut state = self.state.lock();
+            // assume the next request to open a bid corresponds to the current request
+            // TODO consider if the relay mux should have more knowledge about the proposal
+            state.latest_pubkey = bid_request.public_key.clone();
+            state.outstanding_bids.insert(bid_request.clone(), relay_indices);
+        }
 
         Ok(bids[*best_index].0.clone())
     }
@@ -205,12 +204,9 @@ impl BlindedBlockProvider for RelayMux {
         signed_block: &mut SignedBlindedBeaconBlock,
     ) -> Result<ExecutionPayload, BlindedBlockProviderError> {
         let relay_indices = {
-            let mut state = self.state.lock().unwrap();
+            let mut state = self.state.lock();
             let key = bid_key_from(signed_block, &state.latest_pubkey);
-            match state.outstanding_bids.remove(&key) {
-                Some(indices) => indices,
-                None => return Err(Error::MissingOpenBid.into()),
-            }
+            state.outstanding_bids.remove(&key).ok_or(Error::MissingOpenBid)?
         };
 
         let signed_block = &signed_block;

mev-build-rs/Cargo.toml

@@ -18,6 +18,7 @@ async-trait = "0.1.53"
 serde = { version = "1.0", features = ["derive"], optional = true }
 serde_json = { version = "1.0.81", optional = true }
 thiserror = "1.0.30"
+parking_lot = "0.12.1"
 
 ethereum-consensus = { git = "https://github.com/ralexstokes/ethereum-consensus", rev = "a8110af76d97bf2bf27fb987a671808fcbdf1834" }
 beacon-api-client = { git = "https://github.com/ralexstokes/beacon-api-client", rev = "7d5d8dad1648f771573f42585ad8080a45b05689", optional = true }

mev-build-rs/src/builder/engine_builder.rs

@@ -11,11 +11,8 @@ use ethereum_consensus::{
     ssz::ByteList,
     state_transition::Context,
 };
-use std::{
-    collections::HashMap,
-    ops::Deref,
-    sync::{Arc, Mutex},
-};
+use parking_lot::Mutex;
+use std::{collections::HashMap, ops::Deref, sync::Arc};
 
 #[derive(Clone)]
 pub struct EngineBuilder(Arc<EngineBuilderInner>);
@@ -66,15 +63,16 @@ impl EngineBuilder {
         &self,
         request: &PayloadRequest,
     ) -> Result<ExecutionPayloadWithValue, Error> {
-        let state = self.state.lock().expect("can lock");
-        let preferences = state
+        let (fee_recipient, gas_limit) = self
+            .state
+            .lock()
             .validator_preferences
             .get(&request.public_key)
+            .map(|preferences| {
+                (preferences.message.fee_recipient.clone(), preferences.message.gas_limit)
+            })
             .ok_or_else(|| Error::MissingPreferences(request.public_key.clone()))?;
 
-        let fee_recipient = preferences.message.fee_recipient.clone();
-        let gas_limit = preferences.message.gas_limit;
-
         let payload = ExecutionPayload {
             parent_hash: request.parent_hash.clone(),
             fee_recipient,
@@ -93,7 +91,7 @@ impl EngineBuilder {
     ) -> Result<(), BlindedBlockProviderError> {
         // TODO this assumes registrations have already been validated by relay
         // will eventually remove this assumption
-        let mut state = self.state.lock().expect("can lock");
+        let mut state = self.state.lock();
         for registration in registrations {
             let public_key = registration.message.public_key.clone();
             state.validator_preferences.insert(public_key, registration.clone());

mev-relay-rs/Cargo.toml

@@ -12,11 +12,11 @@ tokio = { version = "1.0", features = ["full"] }
 tracing = "0.1"
 futures = "0.3.21"
 async-trait = "0.1.53"
+parking_lot = "0.12.1"
 
 thiserror = "1.0.30"
 http = "0.2.7"
 url = { version = "2.2.2", default-features = false }
-
 serde = { version = "1.0", features = ["derive"] }
 
 ethereum-consensus = { git = "https://github.com/ralexstokes/ethereum-consensus", rev = "a8110af76d97bf2bf27fb987a671808fcbdf1834" }

mev-relay-rs/src/relay.rs

@@ -18,12 +18,8 @@ use mev_build_rs::{
     EngineBuilder, ExecutionPayload, ExecutionPayloadHeader, ExecutionPayloadWithValue,
     SignedBlindedBeaconBlock, SignedBuilderBid, SignedValidatorRegistration,
 };
-use std::{
-    cmp::Ordering,
-    collections::HashMap,
-    ops::Deref,
-    sync::{Arc, Mutex},
-};
+use parking_lot::Mutex;
+use std::{cmp::Ordering, collections::HashMap, ops::Deref, sync::Arc};
 use thiserror::Error;
 
 // `PROPOSAL_TOLERANCE_DELAY` controls how aggresively the relay drops "old" execution payloads
@@ -265,7 +261,7 @@ impl Relay {
                 // TODO grab validators more efficiently
                 self.load_full_validator_set().await;
             }
-            let mut state = self.state.lock().unwrap();
+            let mut state = self.state.lock();
             state
                 .execution_payloads
                 .retain(|bid_request, _| bid_request.slot + PROPOSAL_TOLERANCE_DELAY >= slot);
@@ -280,7 +276,7 @@ impl BlindedBlockProvider for Relay {
         registrations: &mut [SignedValidatorRegistration],
     ) -> Result<(), BlindedBlockProviderError> {
         let mut new_registrations = {
-            let mut state = self.state.lock().expect("can lock");
+            let mut state = self.state.lock();
             let current_time = get_current_unix_time_in_secs();
             let mut new_registrations = vec![];
             for registration in registrations.iter_mut() {
@@ -319,18 +315,21 @@ impl BlindedBlockProvider for Relay {
         let ExecutionPayloadWithValue { mut payload, value } =
             self.builder.get_payload_with_value(bid_request)?;
 
-        let mut state = self.state.lock().expect("can lock");
+        let header = {
+            let mut state = self.state.lock();
 
-        let preferences = state
-            .validator_preferences
-            .get(&bid_request.public_key)
-            .ok_or(Error::UnknownValidator)?;
+            let preferences = state
+                .validator_preferences
+                .get(&bid_request.public_key)
+                .ok_or(Error::UnknownValidator)?;
 
-        validate_execution_payload(&payload, &value, &preferences.message)?;
+            validate_execution_payload(&payload, &value, &preferences.message)?;
 
-        let header = ExecutionPayloadHeader::try_from(&mut payload)?;
+            let header = ExecutionPayloadHeader::try_from(&mut payload)?;
 
-        state.execution_payloads.insert(bid_request.clone(), payload);
+            state.execution_payloads.insert(bid_request.clone(), payload);
+            header
+        };
 
         let mut bid = BuilderBid { header, value, public_key: self.public_key.clone() };
 
@@ -353,8 +352,10 @@ impl BlindedBlockProvider for Relay {
             public_key,
         };
 
-        let mut state = self.state.lock().expect("can lock");
-        let mut payload = state.execution_payloads.remove(&bid_request).ok_or(Error::UnknownBid)?;
+        let mut payload = {
+            let mut state = self.state.lock();
+            state.execution_payloads.remove(&bid_request).ok_or(Error::UnknownBid)?
+        };
 
         validate_signed_block(signed_block, &bid_request.public_key, &mut payload, &self.context)?;
 

mev-relay-rs/src/validator_summary_provider.rs

@@ -1,6 +1,7 @@
 use beacon_api_client::{Client, Error as ApiError, StateId, ValidatorStatus, ValidatorSummary};
 use ethereum_consensus::primitives::{BlsPublicKey, ValidatorIndex};
-use std::{collections::HashMap, sync::Mutex};
+use parking_lot::Mutex;
+use std::collections::HashMap;
 use thiserror::Error;
 
 #[derive(Debug, Error)]
@@ -32,7 +33,7 @@ impl ValidatorSummaryProvider {
 
     pub async fn load(&self) -> Result<(), Error> {
         let summaries = self.client.get_validators(StateId::Head, &[], &[]).await?;
-        let mut state = self.state.lock().expect("can lock");
+        let mut state = self.state.lock();
         for summary in summaries.into_iter() {
             let public_key = summary.validator.public_key.clone();
             state.pubkeys_by_index.insert(summary.index, public_key.clone());
@@ -42,13 +43,16 @@ impl ValidatorSummaryProvider {
     }
 
     pub fn get_status(&self, public_key: &BlsPublicKey) -> Result<ValidatorStatus, Error> {
-        let state = self.state.lock().expect("can lock");
-        let validator = state.validators.get(public_key).ok_or(Error::UnknownPubkey)?;
-        Ok(validator.status)
+        let state = self.state.lock();
+        state
+            .validators
+            .get(public_key)
+            .map(|validator| validator.status)
+            .ok_or(Error::UnknownPubkey)
     }
 
     pub fn get_public_key(&self, index: ValidatorIndex) -> Result<BlsPublicKey, Error> {
-        let state = self.state.lock().expect("can lock");
-        state.pubkeys_by_index.get(&index).ok_or(Error::UnknownIndex).map(Clone::clone)
+        let state = self.state.lock();
+        state.pubkeys_by_index.get(&index).cloned().ok_or(Error::UnknownIndex)
     }
 }