Deprecate exchangeTransitionConfiguration functionality (sigp#4517)

Solves sigp#4442

EL clients log errors if we don't query this endpoint, but they are making releases that remove this error logging. After those are out we can stop calling it, after which point EL teams will remove the endpoint entirely.
Refer https://hackmd.io/@n0ble/deprecate-exchgTC

beacon_node/beacon_chain/src/merge_readiness.rs

@@ -86,9 +86,6 @@ pub enum MergeReadiness {
         #[serde(serialize_with = "serialize_uint256")]
         current_difficulty: Option<Uint256>,
     },
-    /// The transition configuration with the EL failed, there might be a problem with
-    /// connectivity, authentication or a difference in configuration.
-    ExchangeTransitionConfigurationFailed { error: String },
     /// The EL can be reached and has the correct configuration, however it's not yet synced.
     NotSynced,
     /// The user has not configured this node to use an execution endpoint.
@@ -109,12 +106,6 @@ impl fmt::Display for MergeReadiness {
                     params, current_difficulty
                 )
             }
-            MergeReadiness::ExchangeTransitionConfigurationFailed { error } => write!(
-                f,
-                "Could not confirm the transition configuration with the \
-                    execution endpoint: {:?}",
-                error
-            ),
             MergeReadiness::NotSynced => write!(
                 f,
                 "The execution endpoint is connected and configured, \
@@ -155,14 +146,6 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
     /// Attempts to connect to the EL and confirm that it is ready for the merge.
     pub async fn check_merge_readiness(&self) -> MergeReadiness {
         if let Some(el) = self.execution_layer.as_ref() {
-            if let Err(e) = el.exchange_transition_configuration(&self.spec).await {
-                // The EL was either unreachable, responded with an error or has a different
-                // configuration.
-                return MergeReadiness::ExchangeTransitionConfigurationFailed {
-                    error: format!("{:?}", e),
-                };
-            }
-
             if !el.is_synced_for_notifier().await {
                 // The EL is not synced.
                 return MergeReadiness::NotSynced;

beacon_node/client/src/builder.rs

@@ -858,9 +858,6 @@ where
                     execution_layer.spawn_clean_proposer_caches_routine::<TSlotClock>(
                         beacon_chain.slot_clock.clone(),
                     );
-
-                    // Spawns a routine that polls the `exchange_transition_configuration` endpoint.
-                    execution_layer.spawn_transition_configuration_poll(beacon_chain.spec.clone());
                 }
 
                 // Spawn a service to publish BLS to execution changes at the Capella fork.

beacon_node/client/src/notifier.rs

@@ -404,14 +404,6 @@ async fn merge_readiness_logging<T: BeaconChainTypes>(
                 "config" => ?other
             ),
         },
-        readiness @ MergeReadiness::ExchangeTransitionConfigurationFailed { error: _ } => {
-            error!(
-                log,
-                "Not ready for merge";
-                "info" => %readiness,
-                "hint" => "try updating Lighthouse and/or the execution layer",
-            )
-        }
         readiness @ MergeReadiness::NotSynced => warn!(
             log,
             "Not ready for merge";

beacon_node/execution_layer/src/lib.rs

@@ -84,8 +84,6 @@ const EXECUTION_BLOCKS_LRU_CACHE_SIZE: usize = 128;
 const DEFAULT_SUGGESTED_FEE_RECIPIENT: [u8; 20] =
     [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1];
 
-const CONFIG_POLL_INTERVAL: Duration = Duration::from_secs(60);
-
 /// A payload alongside some information about where it came from.
 pub enum ProvenancedPayload<P> {
     /// A good ol' fashioned farm-to-table payload from your local EE.
@@ -551,24 +549,6 @@ impl<T: EthSpec> ExecutionLayer<T> {
         self.spawn(preparation_cleaner, "exec_preparation_cleanup");
     }
 
-    /// Spawns a routine that polls the `exchange_transition_configuration` endpoint.
-    pub fn spawn_transition_configuration_poll(&self, spec: ChainSpec) {
-        let routine = |el: ExecutionLayer<T>| async move {
-            loop {
-                if let Err(e) = el.exchange_transition_configuration(&spec).await {
-                    error!(
-                        el.log(),
-                        "Failed to check transition config";
-                        "error" => ?e
-                    );
-                }
-                sleep(CONFIG_POLL_INTERVAL).await;
-            }
-        };
-
-        self.spawn(routine, "exec_config_poll");
-    }
-
     /// Returns `true` if the execution engine is synced and reachable.
     pub async fn is_synced(&self) -> bool {
         self.engine().is_synced().await
@@ -1391,53 +1371,6 @@ impl<T: EthSpec> ExecutionLayer<T> {
         .map_err(Error::EngineError)
     }
 
-    pub async fn exchange_transition_configuration(&self, spec: &ChainSpec) -> Result<(), Error> {
-        let local = TransitionConfigurationV1 {
-            terminal_total_difficulty: spec.terminal_total_difficulty,
-            terminal_block_hash: spec.terminal_block_hash,
-            terminal_block_number: 0,
-        };
-
-        let result = self
-            .engine()
-            .request(|engine| engine.api.exchange_transition_configuration_v1(local))
-            .await;
-
-        match result {
-            Ok(remote) => {
-                if local.terminal_total_difficulty != remote.terminal_total_difficulty
-                    || local.terminal_block_hash != remote.terminal_block_hash
-                {
-                    error!(
-                        self.log(),
-                        "Execution client config mismatch";
-                        "msg" => "ensure lighthouse and the execution client are up-to-date and \
-                                  configured consistently",
-                        "remote" => ?remote,
-                        "local" => ?local,
-                    );
-                    Err(Error::EngineError(Box::new(EngineError::Api {
-                        error: ApiError::TransitionConfigurationMismatch,
-                    })))
-                } else {
-                    debug!(
-                        self.log(),
-                        "Execution client config is OK";
-                    );
-                    Ok(())
-                }
-            }
-            Err(e) => {
-                error!(
-                    self.log(),
-                    "Unable to get transition config";
-                    "error" => ?e,
-                );
-                Err(Error::EngineError(Box::new(e)))
-            }
-        }
-    }
-
     /// Returns the execution engine capabilities resulting from a call to
     /// engine_exchangeCapabilities. If the capabilities cache is not populated,
     /// or if it is populated with a cached result of age >= `age_limit`, this

beacon_node/execution_layer/src/test_utils/handle_rpc.rs

@@ -427,15 +427,6 @@ pub async fn handle_rpc<T: EthSpec>(
 
             Ok(serde_json::to_value(response).unwrap())
         }
-        ENGINE_EXCHANGE_TRANSITION_CONFIGURATION_V1 => {
-            let block_generator = ctx.execution_block_generator.read();
-            let transition_config: TransitionConfigurationV1 = TransitionConfigurationV1 {
-                terminal_total_difficulty: block_generator.terminal_total_difficulty,
-                terminal_block_hash: block_generator.terminal_block_hash,
-                terminal_block_number: block_generator.terminal_block_number,
-            };
-            Ok(serde_json::to_value(transition_config).unwrap())
-        }
         ENGINE_EXCHANGE_CAPABILITIES => {
             let engine_capabilities = ctx.engine_capabilities.read();
             Ok(serde_json::to_value(engine_capabilities.to_response()).unwrap())

testing/execution_engine_integration/src/test_rig.rs

@@ -204,16 +204,6 @@ impl<E: GenericExecutionEngine> TestRig<E> {
         let account1 = ethers_core::types::Address::from_slice(&hex::decode(ACCOUNT1).unwrap());
         let account2 = ethers_core::types::Address::from_slice(&hex::decode(ACCOUNT2).unwrap());
 
-        /*
-         * Check the transition config endpoint.
-         */
-        for ee in [&self.ee_a, &self.ee_b] {
-            ee.execution_layer
-                .exchange_transition_configuration(&self.spec)
-                .await
-                .unwrap();
-        }
-
         /*
          * Read the terminal block hash from both pairs, check it's equal.
          */