Allow per validator fee recipient via flag or file in validator client (similar to graffiti / graffiti-file) (#2924)

## Issue Addressed

#2883 

## Proposed Changes

* Added `suggested-fee-recipient` & `suggested-fee-recipient-file` flags to validator client (similar to graffiti / graffiti-file implementation).
* Added proposer preparation service to VC, which sends the fee-recipient of all known validators to the BN via [/eth/v1/validator/prepare_beacon_proposer](https://github.com/ethereum/beacon-APIs/pull/178) api once per slot
* Added [/eth/v1/validator/prepare_beacon_proposer](https://github.com/ethereum/beacon-APIs/pull/178) api endpoint and preparation data caching
* Added cleanup routine to remove cached proposer preparations when not updated for 2 epochs

## Additional Info

Changed the Implementation following the discussion in #2883.



Co-authored-by: pk910 <philipp@pk910.de>
Co-authored-by: Paul Hauner <paul@paulhauner.com>
Co-authored-by: Philipp K <philipp@pk910.de>

validator_client/src/cli.rs

@@ -127,6 +127,22 @@ pub fn cli_app<'a, 'b>() -> App<'a, 'b> {
                 .takes_value(true)
                 .conflicts_with("graffiti")
         )
+        .arg(
+            Arg::with_name("suggested-fee-recipient")
+                .long("suggested-fee-recipient")
+                .help("The fallback address provided to the BN if nothing suitable is found \
+                           in the validator definitions or fee recipient file.")
+                .value_name("FEE-RECIPIENT")
+                .takes_value(true)
+        )
+        .arg(
+            Arg::with_name("suggested-fee-recipient-file")
+                .long("suggested-fee-recipient-file")
+                .help("The fallback address provided to the BN if nothing suitable is found \
+                           in the validator definitions.")
+                .value_name("FEE-RECIPIENT-FILE")
+                .takes_value(true)
+        )
         /* REST API related arguments */
         .arg(
             Arg::with_name("http")

validator_client/src/config.rs

@@ -1,3 +1,4 @@
+use crate::fee_recipient_file::FeeRecipientFile;
 use crate::graffiti_file::GraffitiFile;
 use crate::{http_api, http_metrics};
 use clap::ArgMatches;
@@ -13,7 +14,7 @@ use slog::{info, warn, Logger};
 use std::fs;
 use std::net::Ipv4Addr;
 use std::path::PathBuf;
-use types::GRAFFITI_BYTES_LEN;
+use types::{Address, GRAFFITI_BYTES_LEN};
 
 pub const DEFAULT_BEACON_NODE: &str = "http://localhost:5052/";
 
@@ -41,6 +42,10 @@ pub struct Config {
     pub graffiti: Option<Graffiti>,
     /// Graffiti file to load per validator graffitis.
     pub graffiti_file: Option<GraffitiFile>,
+    /// Fallback fallback address.
+    pub fee_recipient: Option<Address>,
+    /// Fee recipient file to load per validator suggested-fee-recipients.
+    pub fee_recipient_file: Option<FeeRecipientFile>,
     /// Configuration for the HTTP REST API.
     pub http_api: http_api::Config,
     /// Configuration for the HTTP REST API.
@@ -79,6 +84,8 @@ impl Default for Config {
             use_long_timeouts: false,
             graffiti: None,
             graffiti_file: None,
+            fee_recipient: None,
+            fee_recipient_file: None,
             http_api: <_>::default(),
             http_metrics: <_>::default(),
             monitoring_api: None,
@@ -197,6 +204,25 @@ impl Config {
             }
         }
 
+        if let Some(fee_recipient_file_path) = cli_args.value_of("suggested-fee-recipient-file") {
+            let mut fee_recipient_file = FeeRecipientFile::new(fee_recipient_file_path.into());
+            fee_recipient_file
+                .read_fee_recipient_file()
+                .map_err(|e| format!("Error reading suggested-fee-recipient file: {:?}", e))?;
+            config.fee_recipient_file = Some(fee_recipient_file);
+            info!(
+                log,
+                "Successfully loaded suggested-fee-recipient file";
+                "path" => fee_recipient_file_path
+            );
+        }
+
+        if let Some(input_fee_recipient) =
+            parse_optional::<Address>(cli_args, "suggested-fee-recipient")?
+        {
+            config.fee_recipient = Some(input_fee_recipient);
+        }
+
         if let Some(tls_certs) = parse_optional::<String>(cli_args, "beacon-nodes-tls-certs")? {
             config.beacon_nodes_tls_certs = Some(tls_certs.split(',').map(PathBuf::from).collect());
         }

validator_client/src/fee_recipient_file.rs

@@ -0,0 +1,184 @@
+use serde_derive::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::fs::File;
+use std::io::{prelude::*, BufReader};
+use std::path::PathBuf;
+use std::str::FromStr;
+
+use bls::PublicKeyBytes;
+use types::Address;
+
+#[derive(Debug)]
+#[allow(clippy::enum_variant_names)]
+pub enum Error {
+    InvalidFile(std::io::Error),
+    InvalidLine(String),
+    InvalidPublicKey(String),
+    InvalidFeeRecipient(String),
+}
+
+/// Struct to load validator fee-recipients from file.
+/// The fee-recipient file is expected to have the following structure
+///
+/// default: 0x00000000219ab540356cbb839cbe05303d7705fa
+/// public_key1: fee-recipient1
+/// public_key2: fee-recipient2
+/// ...
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FeeRecipientFile {
+    fee_recipient_path: PathBuf,
+    fee_recipients: HashMap<PublicKeyBytes, Address>,
+    default: Option<Address>,
+}
+
+impl FeeRecipientFile {
+    pub fn new(fee_recipient_path: PathBuf) -> Self {
+        Self {
+            fee_recipient_path,
+            fee_recipients: HashMap::new(),
+            default: None,
+        }
+    }
+
+    /// Returns the fee-recipient corresponding to the given public key if present, else returns the
+    /// default fee-recipient.
+    ///
+    /// Returns an error if loading from the fee-recipient file fails.
+    pub fn get_fee_recipient(&self, public_key: &PublicKeyBytes) -> Result<Option<Address>, Error> {
+        Ok(self
+            .fee_recipients
+            .get(public_key)
+            .copied()
+            .or(self.default))
+    }
+
+    /// Loads the fee-recipient file and populates the default fee-recipient and `fee_recipients` hashmap.
+    /// Returns the fee-recipient corresponding to the given public key if present, else returns the
+    /// default fee-recipient.
+    ///
+    /// Returns an error if loading from the fee-recipient file fails.
+    pub fn load_fee_recipient(
+        &mut self,
+        public_key: &PublicKeyBytes,
+    ) -> Result<Option<Address>, Error> {
+        self.read_fee_recipient_file()?;
+        Ok(self
+            .fee_recipients
+            .get(public_key)
+            .copied()
+            .or(self.default))
+    }
+
+    /// Reads from a fee-recipient file with the specified format and populates the default value
+    /// and the hashmap.
+    ///
+    /// Returns an error if the file does not exist, or if the format is invalid.
+    pub fn read_fee_recipient_file(&mut self) -> Result<(), Error> {
+        let file = File::open(self.fee_recipient_path.as_path()).map_err(Error::InvalidFile)?;
+        let reader = BufReader::new(file);
+
+        let lines = reader.lines();
+
+        self.default = None;
+        self.fee_recipients.clear();
+
+        for line in lines {
+            let line = line.map_err(|e| Error::InvalidLine(e.to_string()))?;
+            let (pk_opt, fee_recipient) = read_line(&line)?;
+            match pk_opt {
+                Some(pk) => {
+                    self.fee_recipients.insert(pk, fee_recipient);
+                }
+                None => self.default = Some(fee_recipient),
+            }
+        }
+        Ok(())
+    }
+}
+
+/// Parses a line from the fee-recipient file.
+///
+/// `Ok((None, fee_recipient))` represents the fee-recipient for the default key.
+/// `Ok((Some(pk), fee_recipient))` represents fee-recipient for the public key `pk`.
+/// Returns an error if the line is in the wrong format or does not contain a valid public key or fee-recipient.
+fn read_line(line: &str) -> Result<(Option<PublicKeyBytes>, Address), Error> {
+    if let Some(i) = line.find(':') {
+        let (key, value) = line.split_at(i);
+        // Note: `value.len() >=1` so `value[1..]` is safe
+        let fee_recipient = Address::from_str(value[1..].trim())
+            .map_err(|e| Error::InvalidFeeRecipient(e.to_string()))?;
+        if key == "default" {
+            Ok((None, fee_recipient))
+        } else {
+            let pk = PublicKeyBytes::from_str(key).map_err(Error::InvalidPublicKey)?;
+            Ok((Some(pk), fee_recipient))
+        }
+    } else {
+        Err(Error::InvalidLine(format!("Missing delimiter: {}", line)))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use bls::Keypair;
+    use std::io::LineWriter;
+    use tempfile::TempDir;
+
+    const DEFAULT_FEE_RECIPIENT: &str = "0x00000000219ab540356cbb839cbe05303d7705fa";
+    const CUSTOM_FEE_RECIPIENT1: &str = "0x4242424242424242424242424242424242424242";
+    const CUSTOM_FEE_RECIPIENT2: &str = "0x0000000000000000000000000000000000000001";
+    const PK1: &str = "0x800012708dc03f611751aad7a43a082142832b5c1aceed07ff9b543cf836381861352aa923c70eeb02018b638aa306aa";
+    const PK2: &str = "0x80001866ce324de7d80ec73be15e2d064dcf121adf1b34a0d679f2b9ecbab40ce021e03bb877e1a2fe72eaaf475e6e21";
+
+    // Create a fee-recipient file in the required format and return a path to the file.
+    fn create_fee_recipient_file() -> PathBuf {
+        let temp = TempDir::new().unwrap();
+        let pk1 = PublicKeyBytes::deserialize(&hex::decode(&PK1[2..]).unwrap()).unwrap();
+        let pk2 = PublicKeyBytes::deserialize(&hex::decode(&PK2[2..]).unwrap()).unwrap();
+
+        let file_name = temp.into_path().join("fee_recipient.txt");
+
+        let file = File::create(&file_name).unwrap();
+        let mut fee_recipient_file = LineWriter::new(file);
+        fee_recipient_file
+            .write_all(format!("default: {}\n", DEFAULT_FEE_RECIPIENT).as_bytes())
+            .unwrap();
+        fee_recipient_file
+            .write_all(format!("{}: {}\n", pk1.as_hex_string(), CUSTOM_FEE_RECIPIENT1).as_bytes())
+            .unwrap();
+        fee_recipient_file
+            .write_all(format!("{}: {}\n", pk2.as_hex_string(), CUSTOM_FEE_RECIPIENT2).as_bytes())
+            .unwrap();
+        fee_recipient_file.flush().unwrap();
+        file_name
+    }
+
+    #[test]
+    fn test_load_fee_recipient() {
+        let fee_recipient_file_path = create_fee_recipient_file();
+        let mut gf = FeeRecipientFile::new(fee_recipient_file_path);
+
+        let pk1 = PublicKeyBytes::deserialize(&hex::decode(&PK1[2..]).unwrap()).unwrap();
+        let pk2 = PublicKeyBytes::deserialize(&hex::decode(&PK2[2..]).unwrap()).unwrap();
+
+        // Read once
+        gf.read_fee_recipient_file().unwrap();
+
+        assert_eq!(
+            gf.load_fee_recipient(&pk1).unwrap().unwrap(),
+            Address::from_str(CUSTOM_FEE_RECIPIENT1).unwrap()
+        );
+        assert_eq!(
+            gf.load_fee_recipient(&pk2).unwrap().unwrap(),
+            Address::from_str(CUSTOM_FEE_RECIPIENT2).unwrap()
+        );
+
+        // Random pk should return the default fee-recipient
+        let random_pk = Keypair::random().pk.compress();
+        assert_eq!(
+            gf.load_fee_recipient(&random_pk).unwrap().unwrap(),
+            Address::from_str(DEFAULT_FEE_RECIPIENT).unwrap()
+        );
+    }
+}

validator_client/src/http_api/create_validator.rs

@@ -139,6 +139,7 @@ pub async fn create_validators_mnemonic<P: AsRef<Path>, T: 'static + SlotClock,
                 voting_password_string,
                 request.enable,
                 request.graffiti.clone(),
+                request.suggested_fee_recipient,
             )
             .await
             .map_err(|e| {
@@ -152,6 +153,7 @@ pub async fn create_validators_mnemonic<P: AsRef<Path>, T: 'static + SlotClock,
             enabled: request.enable,
             description: request.description.clone(),
             graffiti: request.graffiti.clone(),
+            suggested_fee_recipient: request.suggested_fee_recipient,
             voting_pubkey,
             eth1_deposit_tx_data: eth2_serde_utils::hex::encode(&eth1_deposit_data.rlp),
             deposit_gwei: request.deposit_gwei,
@@ -170,6 +172,7 @@ pub async fn create_validators_web3signer<T: 'static + SlotClock, E: EthSpec>(
             enabled: request.enable,
             voting_public_key: request.voting_public_key.clone(),
             graffiti: request.graffiti.clone(),
+            suggested_fee_recipient: request.suggested_fee_recipient,
             description: request.description.clone(),
             signing_definition: SigningDefinition::Web3Signer {
                 url: request.url.clone(),

validator_client/src/http_api/keystores.rs

@@ -201,6 +201,7 @@ fn import_single_keystore<T: SlotClock + 'static, E: EthSpec>(
             password,
             true,
             None,
+            None,
         ))
         .map_err(|e| format!("failed to initialize validator: {:?}", e))?;
 

validator_client/src/http_api/mod.rs

@@ -409,6 +409,7 @@ pub fn serve<T: 'static + SlotClock + Clone, E: EthSpec>(
                     drop(validator_dir);
                     let voting_password = body.password.clone();
                     let graffiti = body.graffiti.clone();
+                    let suggested_fee_recipient = body.suggested_fee_recipient;
 
                     let validator_def = {
                         if let Some(runtime) = runtime.upgrade() {
@@ -418,6 +419,7 @@ pub fn serve<T: 'static + SlotClock + Clone, E: EthSpec>(
                                     voting_password,
                                     body.enable,
                                     graffiti,
+                                    suggested_fee_recipient,
                                 ))
                                 .map_err(|e| {
                                     warp_utils::reject::custom_server_error(format!(

validator_client/src/http_api/tests.rs

@@ -267,6 +267,7 @@ impl ApiTester {
                 enable: !s.disabled.contains(&i),
                 description: format!("boi #{}", i),
                 graffiti: None,
+                suggested_fee_recipient: None,
                 deposit_gwei: E::default_spec().max_effective_balance,
             })
             .collect::<Vec<_>>();
@@ -397,6 +398,7 @@ impl ApiTester {
                     .into(),
                 keystore,
                 graffiti: None,
+                suggested_fee_recipient: None,
             };
 
             self.client
@@ -414,6 +416,7 @@ impl ApiTester {
                 .into(),
             keystore,
             graffiti: None,
+            suggested_fee_recipient: None,
         };
 
         let response = self
@@ -449,6 +452,7 @@ impl ApiTester {
                     enable: s.enabled,
                     description: format!("{}", i),
                     graffiti: None,
+                    suggested_fee_recipient: None,
                     voting_public_key: kp.pk,
                     url: format!("http://signer_{}.com/", i),
                     root_certificate_path: None,
@@ -574,6 +578,7 @@ fn routes_with_invalid_auth() {
                         enable: <_>::default(),
                         description: <_>::default(),
                         graffiti: <_>::default(),
+                        suggested_fee_recipient: <_>::default(),
                         deposit_gwei: <_>::default(),
                     }])
                     .await
@@ -602,6 +607,7 @@ fn routes_with_invalid_auth() {
                         enable: <_>::default(),
                         keystore,
                         graffiti: <_>::default(),
+                        suggested_fee_recipient: <_>::default(),
                     })
                     .await
             })

validator_client/src/http_api/tests/keystores.rs

@@ -37,6 +37,7 @@ fn web3signer_validator_with_pubkey(pubkey: PublicKey) -> Web3SignerValidatorReq
         enable: true,
         description: "".into(),
         graffiti: None,
+        suggested_fee_recipient: None,
         voting_public_key: pubkey,
         url: web3_signer_url(),
         root_certificate_path: None,

validator_client/src/initialized_validators.rs

@@ -27,7 +27,7 @@ use std::io::{self, Read};
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use std::time::Duration;
-use types::{Graffiti, Keypair, PublicKey, PublicKeyBytes};
+use types::{Address, Graffiti, Keypair, PublicKey, PublicKeyBytes};
 use url::{ParseError, Url};
 use validator_dir::Builder as ValidatorDirBuilder;
 
@@ -104,6 +104,7 @@ impl From<LockfileError> for Error {
 pub struct InitializedValidator {
     signing_method: Arc<SigningMethod>,
     graffiti: Option<Graffiti>,
+    suggested_fee_recipient: Option<Address>,
     /// The validators index in `state.validators`, to be updated by an external service.
     index: Option<u64>,
 }
@@ -269,6 +270,7 @@ impl InitializedValidator {
         Ok(Self {
             signing_method: Arc::new(signing_method),
             graffiti: def.graffiti.map(Into::into),
+            suggested_fee_recipient: def.suggested_fee_recipient,
             index: None,
         })
     }
@@ -538,6 +540,14 @@ impl InitializedValidators {
         self.validators.get(public_key).and_then(|v| v.graffiti)
     }
 
+    /// Returns the `suggested_fee_recipient` for a given public key specified in the
+    /// `ValidatorDefinitions`.
+    pub fn suggested_fee_recipient(&self, public_key: &PublicKeyBytes) -> Option<Address> {
+        self.validators
+            .get(public_key)
+            .and_then(|v| v.suggested_fee_recipient)
+    }
+
     /// Sets the `InitializedValidator` and `ValidatorDefinition` `enabled` values.
     ///
     /// ## Notes

validator_client/src/lib.rs

@@ -5,10 +5,12 @@ mod check_synced;
 mod cli;
 mod config;
 mod duties_service;
+mod fee_recipient_file;
 mod graffiti_file;
 mod http_metrics;
 mod key_cache;
 mod notifier;
+mod preparation_service;
 mod signing_method;
 mod sync_committee_service;
 
@@ -38,6 +40,7 @@ use eth2::{reqwest::ClientBuilder, BeaconNodeHttpClient, StatusCode, Timeouts};
 use http_api::ApiSecret;
 use notifier::spawn_notifier;
 use parking_lot::RwLock;
+use preparation_service::{PreparationService, PreparationServiceBuilder};
 use reqwest::Certificate;
 use slog::{error, info, warn, Logger};
 use slot_clock::SlotClock;
@@ -82,6 +85,7 @@ pub struct ProductionValidatorClient<T: EthSpec> {
     attestation_service: AttestationService<SystemTimeSlotClock, T>,
     sync_committee_service: SyncCommitteeService<SystemTimeSlotClock, T>,
     doppelganger_service: Option<Arc<DoppelgangerService>>,
+    preparation_service: PreparationService<SystemTimeSlotClock, T>,
     validator_store: Arc<ValidatorStore<SystemTimeSlotClock, T>>,
     http_api_listen_addr: Option<SocketAddr>,
     config: Config,
@@ -406,6 +410,15 @@ impl<T: EthSpec> ProductionValidatorClient<T> {
             .runtime_context(context.service_context("attestation".into()))
             .build()?;
 
+        let preparation_service = PreparationServiceBuilder::new()
+            .slot_clock(slot_clock.clone())
+            .validator_store(validator_store.clone())
+            .beacon_nodes(beacon_nodes.clone())
+            .runtime_context(context.service_context("preparation".into()))
+            .fee_recipient(config.fee_recipient)
+            .fee_recipient_file(config.fee_recipient_file.clone())
+            .build()?;
+
         let sync_committee_service = SyncCommitteeService::new(
             duties_service.clone(),
             validator_store.clone(),
@@ -427,6 +440,7 @@ impl<T: EthSpec> ProductionValidatorClient<T> {
             attestation_service,
             sync_committee_service,
             doppelganger_service,
+            preparation_service,
             validator_store,
             config,
             http_api_listen_addr: None,
@@ -458,6 +472,11 @@ impl<T: EthSpec> ProductionValidatorClient<T> {
             .start_update_service(&self.context.eth2_config.spec)
             .map_err(|e| format!("Unable to start sync committee service: {}", e))?;
 
+        self.preparation_service
+            .clone()
+            .start_update_service(&self.context.eth2_config.spec)
+            .map_err(|e| format!("Unable to start preparation service: {}", e))?;
+
         if let Some(doppelganger_service) = self.doppelganger_service.clone() {
             DoppelgangerService::start_update_service(
                 doppelganger_service,

validator_client/src/preparation_service.rs

@@ -0,0 +1,278 @@
+use crate::beacon_node_fallback::{BeaconNodeFallback, RequireSynced};
+use crate::{
+    fee_recipient_file::FeeRecipientFile,
+    validator_store::{DoppelgangerStatus, ValidatorStore},
+};
+use environment::RuntimeContext;
+use slog::{debug, error, info};
+use slot_clock::SlotClock;
+use std::ops::Deref;
+use std::sync::Arc;
+use tokio::time::{sleep, Duration};
+use types::{Address, ChainSpec, EthSpec, ProposerPreparationData};
+
+/// Builds an `PreparationService`.
+pub struct PreparationServiceBuilder<T: SlotClock + 'static, E: EthSpec> {
+    validator_store: Option<Arc<ValidatorStore<T, E>>>,
+    slot_clock: Option<T>,
+    beacon_nodes: Option<Arc<BeaconNodeFallback<T, E>>>,
+    context: Option<RuntimeContext<E>>,
+    fee_recipient: Option<Address>,
+    fee_recipient_file: Option<FeeRecipientFile>,
+}
+
+impl<T: SlotClock + 'static, E: EthSpec> PreparationServiceBuilder<T, E> {
+    pub fn new() -> Self {
+        Self {
+            validator_store: None,
+            slot_clock: None,
+            beacon_nodes: None,
+            context: None,
+            fee_recipient: None,
+            fee_recipient_file: None,
+        }
+    }
+
+    pub fn validator_store(mut self, store: Arc<ValidatorStore<T, E>>) -> Self {
+        self.validator_store = Some(store);
+        self
+    }
+
+    pub fn slot_clock(mut self, slot_clock: T) -> Self {
+        self.slot_clock = Some(slot_clock);
+        self
+    }
+
+    pub fn beacon_nodes(mut self, beacon_nodes: Arc<BeaconNodeFallback<T, E>>) -> Self {
+        self.beacon_nodes = Some(beacon_nodes);
+        self
+    }
+
+    pub fn runtime_context(mut self, context: RuntimeContext<E>) -> Self {
+        self.context = Some(context);
+        self
+    }
+
+    pub fn fee_recipient(mut self, fee_recipient: Option<Address>) -> Self {
+        self.fee_recipient = fee_recipient;
+        self
+    }
+
+    pub fn fee_recipient_file(mut self, fee_recipient_file: Option<FeeRecipientFile>) -> Self {
+        self.fee_recipient_file = fee_recipient_file;
+        self
+    }
+
+    pub fn build(self) -> Result<PreparationService<T, E>, String> {
+        Ok(PreparationService {
+            inner: Arc::new(Inner {
+                validator_store: self
+                    .validator_store
+                    .ok_or("Cannot build PreparationService without validator_store")?,
+                slot_clock: self
+                    .slot_clock
+                    .ok_or("Cannot build PreparationService without slot_clock")?,
+                beacon_nodes: self
+                    .beacon_nodes
+                    .ok_or("Cannot build PreparationService without beacon_nodes")?,
+                context: self
+                    .context
+                    .ok_or("Cannot build PreparationService without runtime_context")?,
+                fee_recipient: self.fee_recipient,
+                fee_recipient_file: self.fee_recipient_file,
+            }),
+        })
+    }
+}
+
+/// Helper to minimise `Arc` usage.
+pub struct Inner<T, E: EthSpec> {
+    validator_store: Arc<ValidatorStore<T, E>>,
+    slot_clock: T,
+    beacon_nodes: Arc<BeaconNodeFallback<T, E>>,
+    context: RuntimeContext<E>,
+    fee_recipient: Option<Address>,
+    fee_recipient_file: Option<FeeRecipientFile>,
+}
+
+/// Attempts to produce proposer preparations for all known validators at the beginning of each epoch.
+pub struct PreparationService<T, E: EthSpec> {
+    inner: Arc<Inner<T, E>>,
+}
+
+impl<T, E: EthSpec> Clone for PreparationService<T, E> {
+    fn clone(&self) -> Self {
+        Self {
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+impl<T, E: EthSpec> Deref for PreparationService<T, E> {
+    type Target = Inner<T, E>;
+
+    fn deref(&self) -> &Self::Target {
+        self.inner.deref()
+    }
+}
+
+impl<T: SlotClock + 'static, E: EthSpec> PreparationService<T, E> {
+    /// Starts the service which periodically produces proposer preparations.
+    pub fn start_update_service(self, spec: &ChainSpec) -> Result<(), String> {
+        let log = self.context.log().clone();
+
+        let slot_duration = Duration::from_secs(spec.seconds_per_slot);
+        let duration_to_next_epoch = self
+            .slot_clock
+            .duration_to_next_epoch(E::slots_per_epoch())
+            .ok_or("Unable to determine duration to next epoch")?;
+
+        info!(
+            log,
+            "Proposer preparation service started";
+            "next_update_millis" => duration_to_next_epoch.as_millis()
+        );
+
+        let executor = self.context.executor.clone();
+        let spec = spec.clone();
+
+        let interval_fut = async move {
+            loop {
+                // Poll the endpoint immediately to ensure fee recipients are received.
+                self.prepare_proposers_and_publish(&spec)
+                    .await
+                    .map_err(|e| {
+                        error!(
+                            log,
+                            "Error during proposer preparation";
+                            "error" => format!("{:?}", e),
+                        )
+                    })
+                    .unwrap_or(());
+
+                if let Some(duration_to_next_slot) = self.slot_clock.duration_to_next_slot() {
+                    sleep(duration_to_next_slot).await;
+                } else {
+                    error!(log, "Failed to read slot clock");
+                    // If we can't read the slot clock, just wait another slot.
+                    sleep(slot_duration).await;
+                }
+            }
+        };
+
+        executor.spawn(interval_fut, "preparation_service");
+        Ok(())
+    }
+
+    /// Prepare proposer preparations and send to beacon node
+    async fn prepare_proposers_and_publish(&self, spec: &ChainSpec) -> Result<(), String> {
+        let preparation_data = self.collect_preparation_data(spec);
+        if !preparation_data.is_empty() {
+            self.publish_preparation_data(preparation_data).await?;
+        }
+
+        Ok(())
+    }
+
+    fn collect_preparation_data(&self, spec: &ChainSpec) -> Vec<ProposerPreparationData> {
+        let log = self.context.log();
+
+        let fee_recipient_file = self
+            .fee_recipient_file
+            .clone()
+            .map(|mut fee_recipient_file| {
+                fee_recipient_file
+                    .read_fee_recipient_file()
+                    .map_err(|e| {
+                        error!(
+                            log,
+                            "{}", format!("Error loading fee-recipient file: {:?}", e);
+                        );
+                    })
+                    .unwrap_or(());
+                fee_recipient_file
+            });
+
+        let all_pubkeys: Vec<_> = self
+            .validator_store
+            .voting_pubkeys(DoppelgangerStatus::ignored);
+
+        all_pubkeys
+            .into_iter()
+            .filter_map(|pubkey| {
+                let validator_index = self.validator_store.validator_index(&pubkey);
+                if let Some(validator_index) = validator_index {
+                    let fee_recipient = if let Some(from_validator_defs) =
+                        self.validator_store.suggested_fee_recipient(&pubkey)
+                    {
+                        // If there is a `suggested_fee_recipient` in the validator definitions yaml
+                        // file, use that value.
+                        Some(from_validator_defs)
+                    } else {
+                        // If there's nothing in the validator defs file, check the fee recipient
+                        // file.
+                        fee_recipient_file
+                            .as_ref()
+                            .and_then(|f| match f.get_fee_recipient(&pubkey) {
+                                Ok(f) => f,
+                                Err(_e) => None,
+                            })
+                            // If there's nothing in the file, try the process-level default value.
+                            .or(self.fee_recipient)
+                    };
+
+                    if let Some(fee_recipient) = fee_recipient {
+                        Some(ProposerPreparationData {
+                            validator_index,
+                            fee_recipient,
+                        })
+                    } else {
+                        if spec.bellatrix_fork_epoch.is_some() {
+                            error!(
+                                log,
+                                "Validator is missing fee recipient";
+                                "msg" => "update validator_definitions.yml",
+                                "pubkey" => ?pubkey
+                            );
+                        }
+                        None
+                    }
+                } else {
+                    None
+                }
+            })
+            .collect()
+    }
+
+    async fn publish_preparation_data(
+        &self,
+        preparation_data: Vec<ProposerPreparationData>,
+    ) -> Result<(), String> {
+        let log = self.context.log();
+
+        // Post the proposer preparations to the BN.
+        let preparation_data_len = preparation_data.len();
+        let preparation_entries = preparation_data.as_slice();
+        match self
+            .beacon_nodes
+            .first_success(RequireSynced::Yes, |beacon_node| async move {
+                beacon_node
+                    .post_validator_prepare_beacon_proposer(preparation_entries)
+                    .await
+            })
+            .await
+        {
+            Ok(()) => debug!(
+                log,
+                "Published proposer preparation";
+                "count" => preparation_data_len,
+            ),
+            Err(e) => error!(
+                log,
+                "Unable to publish proposer preparation";
+                "error" => %e,
+            ),
+        }
+        Ok(())
+    }
+}

validator_client/src/validator_store.rs

@@ -17,7 +17,7 @@ use std::path::Path;
 use std::sync::Arc;
 use task_executor::TaskExecutor;
 use types::{
-    attestation::Error as AttestationError, graffiti::GraffitiString, AggregateAndProof,
+    attestation::Error as AttestationError, graffiti::GraffitiString, Address, AggregateAndProof,
     Attestation, BeaconBlock, ChainSpec, ContributionAndProof, Domain, Epoch, EthSpec, Fork,
     Graffiti, Hash256, Keypair, PublicKeyBytes, SelectionProof, Signature, SignedAggregateAndProof,
     SignedBeaconBlock, SignedContributionAndProof, Slot, SyncAggregatorSelectionData,
@@ -148,11 +148,13 @@ impl<T: SlotClock + 'static, E: EthSpec> ValidatorStore<T, E> {
         password: ZeroizeString,
         enable: bool,
         graffiti: Option<GraffitiString>,
+        suggested_fee_recipient: Option<Address>,
     ) -> Result<ValidatorDefinition, String> {
         let mut validator_def = ValidatorDefinition::new_keystore_with_password(
             voting_keystore_path,
             Some(password),
             graffiti.map(Into::into),
+            suggested_fee_recipient,
         )
         .map_err(|e| format!("failed to create validator definitions: {:?}", e))?;
 
@@ -351,6 +353,12 @@ impl<T: SlotClock + 'static, E: EthSpec> ValidatorStore<T, E> {
         self.validators.read().graffiti(validator_pubkey)
     }
 
+    pub fn suggested_fee_recipient(&self, validator_pubkey: &PublicKeyBytes) -> Option<Address> {
+        self.validators
+            .read()
+            .suggested_fee_recipient(validator_pubkey)
+    }
+
     pub async fn sign_block(
         &self,
         validator_pubkey: PublicKeyBytes,