feat: Implement /eth/v1/validator/prepare_beacon_proposer endpoint (#631)

* feat: Add prepare_beacon_proposer handler and integrate into validator routes

* fix: Update prepare_beacon_proposer to use Arc<OperationPool> for thread safety

* refactor: Refactor imports and improve formatting in prepare_beacon_proposer handler

* fix: Update endpoint URI for prepare_beacon_proposer to remove version prefix

* refactor: Rename variable 'req' to 'request' for clarity in tests

* refactor: Simplify assertion in test_prepare_beacon_proposer_stores_data

* refactor: Improve formatting of assertion in test_prepare_beacon_proposer_stores_data

Author: NuttakitDW

crates/common/beacon_api_types/src/request.rs

@@ -1,4 +1,4 @@
-use alloy_primitives::B256;
+use alloy_primitives::{Address, B256};
 use ream_bls::BLSSignature;
 use serde::{Deserialize, Serialize};
 
@@ -10,6 +10,13 @@ pub struct ValidatorsPostRequest {
     pub statuses: Option<Vec<ValidatorStatus>>,
 }
 
+#[derive(Debug, Deserialize, Serialize)]
+pub struct PrepareBeaconProposerItem {
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub validator_index: u64,
+    pub fee_recipient: Address,
+}
+
 #[derive(Debug, Deserialize, Serialize)]
 pub struct SyncCommitteeRequestItem {
     #[serde(with = "serde_utils::quoted_u64")]

crates/common/operation_pool/src/lib.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use alloy_primitives::B256;
+use alloy_primitives::{Address, B256};
 use parking_lot::RwLock;
 use ream_consensus::{
     bls_to_execution_change::SignedBLSToExecutionChange, electra::beacon_state::BeaconState,
@@ -12,6 +12,7 @@ use tree_hash::TreeHash;
 pub struct OperationPool {
     signed_voluntary_exits: RwLock<HashMap<u64, SignedVoluntaryExit>>,
     signed_bls_to_execution_changes: RwLock<HashMap<B256, SignedBLSToExecutionChange>>,
+    proposer_preparations: RwLock<HashMap<u64, Address>>,
 }
 
 impl OperationPool {
@@ -60,4 +61,53 @@ impl OperationPool {
     pub fn remove_signed_bls_to_execution_change(&self, root: B256) {
         self.signed_bls_to_execution_changes.write().remove(&root);
     }
+
+    pub fn insert_proposer_preparation(&self, validator_index: u64, fee_recipient: Address) {
+        self.proposer_preparations
+            .write()
+            .insert(validator_index, fee_recipient);
+    }
+
+    pub fn get_proposer_preparation(&self, validator_index: u64) -> Option<Address> {
+        self.proposer_preparations
+            .read()
+            .get(&validator_index)
+            .copied()
+    }
+
+    pub fn get_all_proposer_preparations(&self) -> HashMap<u64, Address> {
+        self.proposer_preparations.read().clone()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_proposer_preparation_operations() {
+        let operation_pool = OperationPool::default();
+        let fee_recipient1 = Address::from([0x11; 20]);
+        let fee_recipient2 = Address::from([0x22; 20]);
+
+        assert_eq!(operation_pool.get_proposer_preparation(1), None);
+
+        operation_pool.insert_proposer_preparation(1, fee_recipient1);
+        assert_eq!(
+            operation_pool.get_proposer_preparation(1),
+            Some(fee_recipient1)
+        );
+
+        operation_pool.insert_proposer_preparation(2, fee_recipient2);
+        let all_preparations = operation_pool.get_all_proposer_preparations();
+        assert_eq!(all_preparations.len(), 2);
+        assert_eq!(all_preparations.get(&1), Some(&fee_recipient1));
+        assert_eq!(all_preparations.get(&2), Some(&fee_recipient2));
+
+        operation_pool.insert_proposer_preparation(1, fee_recipient2);
+        assert_eq!(
+            operation_pool.get_proposer_preparation(1),
+            Some(fee_recipient2)
+        );
+    }
 }

crates/rpc/src/handlers/mod.rs

@@ -8,6 +8,7 @@ pub mod header;
 pub mod light_client;
 pub mod peers;
 pub mod pool;
+pub mod prepare_beacon_proposer;
 pub mod state;
 pub mod syncing;
 pub mod validator;

crates/rpc/src/handlers/prepare_beacon_proposer.rs

@@ -0,0 +1,118 @@
+use std::sync::Arc;
+
+use actix_web::{
+    HttpResponse, Responder, post,
+    web::{Data, Json},
+};
+use ream_beacon_api_types::{error::ApiError, request::PrepareBeaconProposerItem};
+use ream_operation_pool::OperationPool;
+
+#[post("/validator/prepare_beacon_proposer")]
+pub async fn prepare_beacon_proposer(
+    operation_pool: Data<Arc<OperationPool>>,
+    prepare_beacon_proposer_items: Json<Vec<PrepareBeaconProposerItem>>,
+) -> Result<impl Responder, ApiError> {
+    let items = prepare_beacon_proposer_items.into_inner();
+
+    if items.is_empty() {
+        return Err(ApiError::BadRequest("Empty request body".to_string()));
+    }
+
+    for item in items {
+        operation_pool.insert_proposer_preparation(item.validator_index, item.fee_recipient);
+    }
+
+    Ok(HttpResponse::Ok().finish())
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use actix_web::{App, http::StatusCode, test};
+    use alloy_primitives::Address;
+
+    use super::*;
+
+    #[actix_web::test]
+    async fn test_prepare_beacon_proposer_success() {
+        let operation_pool = Arc::new(OperationPool::default());
+        let app = test::init_service(
+            App::new()
+                .app_data(Data::new(operation_pool))
+                .service(prepare_beacon_proposer),
+        )
+        .await;
+
+        let fee_recipient = Address::from([0x42; 20]);
+        let items = vec![
+            PrepareBeaconProposerItem {
+                validator_index: 1,
+                fee_recipient,
+            },
+            PrepareBeaconProposerItem {
+                validator_index: 2,
+                fee_recipient,
+            },
+        ];
+
+        let request = test::TestRequest::post()
+            .uri("/validator/prepare_beacon_proposer")
+            .set_json(&items)
+            .to_request();
+
+        let response = test::call_service(&app, request).await;
+        assert_eq!(response.status(), StatusCode::OK);
+    }
+
+    #[actix_web::test]
+    async fn test_prepare_beacon_proposer_empty_request() {
+        let operation_pool = Arc::new(OperationPool::default());
+        let app = test::init_service(
+            App::new()
+                .app_data(Data::new(operation_pool))
+                .service(prepare_beacon_proposer),
+        )
+        .await;
+
+        let items: Vec<PrepareBeaconProposerItem> = vec![];
+
+        let request = test::TestRequest::post()
+            .uri("/validator/prepare_beacon_proposer")
+            .set_json(&items)
+            .to_request();
+
+        let response = test::call_service(&app, request).await;
+        assert_eq!(response.status(), StatusCode::BAD_REQUEST);
+    }
+
+    #[actix_web::test]
+    async fn test_prepare_beacon_proposer_stores_data() {
+        let operation_pool = Arc::new(OperationPool::default());
+        let app = test::init_service(
+            App::new()
+                .app_data(Data::new(operation_pool.clone()))
+                .service(prepare_beacon_proposer),
+        )
+        .await;
+
+        let fee_recipient = Address::from([0x42; 20]);
+        let items = vec![PrepareBeaconProposerItem {
+            validator_index: 123,
+            fee_recipient,
+        }];
+
+        let request = test::TestRequest::post()
+            .uri("/validator/prepare_beacon_proposer")
+            .set_json(&items)
+            .to_request();
+
+        let response = test::call_service(&app, request).await;
+        assert_eq!(response.status(), StatusCode::OK);
+
+        assert_eq!(
+            operation_pool.get_proposer_preparation(123),
+            Some(fee_recipient)
+        );
+    }
+}

crates/rpc/src/routes/validator.rs

@@ -1,8 +1,12 @@
 use actix_web::web::ServiceConfig;
 
-use crate::handlers::duties::{get_attester_duties, get_proposer_duties};
+use crate::handlers::{
+    duties::{get_attester_duties, get_proposer_duties},
+    prepare_beacon_proposer::prepare_beacon_proposer,
+};
 
 pub fn register_validator_routes(config: &mut ServiceConfig) {
     config.service(get_proposer_duties);
     config.service(get_attester_duties);
+    config.service(prepare_beacon_proposer);
 }