remove executionWitness

Author: kevaundray

beacon_node/execution_layer/src/engine_api/http.rs

@@ -1460,26 +1460,6 @@ impl HttpJsonRpc {
             Err(Error::RequiredMethodUnsupported("engine_forkchoiceUpdated"))
         }
     }
-
-    /// Calls the `debug_executionWitness` method on the execution engine.
-    ///
-    /// This method retrieves the execution witness for a given block, which contains
-    /// the state data needed to re-execute and prove the block's execution.
-    ///
-    /// The block can be specified by number (hex string like "0x1") or tag ("latest", "pending").
-    pub async fn debug_execution_witness(&self, block: &str) -> Result<serde_json::Value, Error> {
-        let params = json!([block]);
-
-        self.rpc_request(
-            "debug_executionWitness",
-            params,
-            // Use a longer timeout since this can be a heavy operation
-            // Though note that this should not take a long time because
-            // we call it near the tip or we can get it from disk.
-            Duration::from_secs(30) * self.execution_timeout_multiplier,
-        )
-        .await
-    }
 }
 
 #[cfg(test)]

beacon_node/execution_layer/src/lib.rs

@@ -2072,23 +2072,6 @@ impl<E: EthSpec> ExecutionLayer<E> {
             Err(Error::NoPayloadBuilder)
         }
     }
-
-    /// Get the execution witness for a given block from the execution layer.
-    ///
-    /// This method calls `debug_executionWitness` on the execution engine, which
-    /// returns the state data needed to re-execute and prove the block's execution.
-    ///
-    /// The block can be specified by number (hex string like "0x1") or tag ("latest", "pending").
-    ///
-    /// TODO(zkproofs): As noted in lighthouse/execution_witness -- we can have the EL
-    /// save this information(last 64 blocks) when newPayload is called and so this method is just fetching it.
-    pub async fn get_execution_witness(&self, block: &str) -> Result<serde_json::Value, Error> {
-        self.engine()
-            .api
-            .debug_execution_witness(block)
-            .await
-            .map_err(Error::ApiError)
-    }
 }
 
 #[derive(AsRefStr)]

beacon_node/http_api/src/lib.rs

@@ -3102,50 +3102,6 @@ pub fn serve<T: BeaconChainTypes>(
                 })
             },
         );
-    // TODO(zkproofs): I think we want to return a block_with_witness
-    // and note the EL could generate this witness when newPayload is called
-    // it gets saved to disk or in memory and then when the EL is asked for it
-    // it just gets it from disk or memory.
-    //
-    // Also consider adding another endpoint that just
-    // returns the unverified payload for those who want to generate the witness
-    // themselves quickly, and don't want to pay the latency cost for payload execution.
-    //
-    // GET lighthouse/execution_witness/{block}
-    // Returns the execution witness for a given block from the execution layer.
-    // The block parameter can be a hex block number (e.g., "0x1") or a tag ("latest", "pending").
-    let get_lighthouse_execution_witness = warp::path("lighthouse")
-        .and(warp::path("execution_witness"))
-        .and(warp::path::param::<String>())
-        .and(warp::path::end())
-        .and(task_spawner_filter.clone())
-        .and(chain_filter.clone())
-        .then(
-            |block: String, task_spawner: TaskSpawner<T::EthSpec>, chain: Arc<BeaconChain<T>>| {
-                task_spawner.spawn_async_with_rejection(Priority::P1, async move {
-                    let execution_layer = chain.execution_layer.as_ref().ok_or_else(|| {
-                        warp_utils::reject::custom_server_error(
-                            "execution layer not configured".to_string(),
-                        )
-                    })?;
-
-                    let witness = execution_layer
-                        .get_execution_witness(&block)
-                        .await
-                        .map_err(|e| {
-                            warp_utils::reject::custom_server_error(format!(
-                                "failed to get execution witness: {:?}",
-                                e
-                            ))
-                        })?;
-
-                    Ok::<_, warp::reject::Rejection>(
-                        warp::reply::json(&api_types::GenericResponse::from(witness))
-                            .into_response(),
-                    )
-                })
-            },
-        );
 
     let get_events = eth_v1
         .clone()
@@ -3378,7 +3334,6 @@ pub fn serve<T: BeaconChainTypes>(
                 .uor(get_beacon_light_client_updates)
                 .uor(get_lighthouse_block_packing_efficiency)
                 .uor(get_lighthouse_merge_readiness)
-                .uor(get_lighthouse_execution_witness)
                 .uor(get_events)
                 .uor(get_expected_withdrawals)
                 .uor(lighthouse_log_events.boxed())

beacon_node/http_api/tests/tests.rs

@@ -2830,22 +2830,6 @@ impl ApiTester {
         self
     }
 
-    pub async fn test_get_lighthouse_execution_witness(self) -> Self {
-        // The mock execution layer doesn't support debug_executionWitness,
-        // so this test verifies the endpoint exists and returns an appropriate error.
-        // TODO(zkproofs): should we add to the mock el? Also might be good to have this
-        // TODO(zkproofs): fail on startup if its needed (or it cna be queried)
-        let result = self.client.get_lighthouse_execution_witness("latest").await;
-
-        // The endpoint should return an error since the mock EL doesn't support this method
-        assert!(
-            result.is_err(),
-            "execution witness endpoint should return error when EL doesn't support the method"
-        );
-
-        self
-    }
-
     pub async fn test_get_config_fork_schedule(self) -> Self {
         let result = self.client.get_config_fork_schedule().await.unwrap().data;
 
@@ -8135,8 +8119,6 @@ async fn lighthouse_endpoints() {
         .test_post_lighthouse_liveness()
         .await
         .test_post_lighthouse_add_remove_peer()
-        .await
-        .test_get_lighthouse_execution_witness()
         .await;
 }
 

common/eth2/src/lighthouse.rs

@@ -313,27 +313,6 @@ impl BeaconNodeHttpClient {
         self.post_with_response(path, &req).await
     }
 
-    /// `GET lighthouse/execution_witness/{block}`
-    ///
-    /// Retrieves the execution witness for a given block, which contains
-    /// the state data needed to re-execute and prove the block's execution.
-    ///
-    /// The block can be specified by number (hex string like "0x1") or tag ("latest", "pending").
-    pub async fn get_lighthouse_execution_witness(
-        &self,
-        block: &str,
-    ) -> Result<GenericResponse<serde_json::Value>, Error> {
-        let mut path = self.server.expose_full().clone();
-
-        path.path_segments_mut()
-            .map_err(|()| Error::InvalidUrl(self.server.clone()))?
-            .push("lighthouse")
-            .push("execution_witness")
-            .push(block);
-
-        self.get(path).await
-    }
-
     /*
      Analysis endpoints.
     */