feat(beacon-network): add json-rpc method to get the latest finalized state root

ethportal-api/src/beacon.rs

@@ -42,6 +42,10 @@ pub trait BeaconNetworkApi {
     #[method(name = "beaconPing")]
     async fn ping(&self, enr: Enr) -> RpcResult<PongInfo>;
 
+    /// Get the finalized state root of the finalized beacon header.
+    #[method(name = "beaconFinalizedStateRoot")]
+    async fn finalized_state_root(&self) -> RpcResult<B256>;
+
     /// Send a FINDNODES request for nodes that fall within the given set of distances, to the
     /// designated peer and wait for a response
     #[method(name = "beaconFindNodes")]

ethportal-api/src/types/jsonrpc/endpoints.rs

@@ -113,6 +113,8 @@ pub enum BeaconEndpoint {
     FindContent(Enr, BeaconContentKey),
     /// params: [enr, distances]
     FindNodes(Enr, Vec<u16>),
+    /// params: None
+    FinalizedStateRoot,
     /// params: node_id
     GetEnr(NodeId),
     /// params: content_key

light-client/src/client.rs

@@ -459,4 +459,8 @@ impl<DB: Database, R: ConsensusRpc + 'static> Client<DB, R> {
     pub async fn get_header(&self) -> Result<BeaconBlockHeader> {
         self.node.read().await.get_header()
     }
+
+    pub async fn get_finalized_header(&self) -> Result<BeaconBlockHeader> {
+        self.node.read().await.get_finalized_header()
+    }
 }

light-client/src/node.rs

@@ -77,6 +77,10 @@ impl<R: ConsensusRpc> Node<R> {
         self.config.chain.chain_id
     }
 
+    pub fn get_finalized_header(&self) -> Result<BeaconBlockHeader> {
+        Ok(self.consensus.get_finalized_header().clone())
+    }
+
     pub fn get_header(&self) -> Result<BeaconBlockHeader> {
         self.check_head_age()?;
         Ok(self.consensus.get_header().clone())

rpc/src/beacon_rpc.rs

@@ -151,6 +151,7 @@ impl BeaconNetworkApiServer for BeaconNetworkApi {
         Ok(result)
     }
 
+    /// Get the optimistic state root of the optimistic beacon header.
     async fn optimistic_state_root(&self) -> RpcResult<B256> {
         let endpoint = BeaconEndpoint::OptimisticStateRoot;
         let result = self.proxy_query_to_beacon_subnet(endpoint).await?;
@@ -170,6 +171,14 @@ impl BeaconNetworkApiServer for BeaconNetworkApi {
         Ok(result)
     }
 
+    /// Get the finalized state root of the finalized beacon header.
+    async fn finalized_state_root(&self) -> RpcResult<B256> {
+        let endpoint = BeaconEndpoint::FinalizedStateRoot;
+        let result = self.proxy_query_to_beacon_subnet(endpoint).await?;
+        let result: B256 = from_value(result)?;
+        Ok(result)
+    }
+
     /// Lookup a target content key in the network
     async fn recursive_find_content(
         &self,

trin-beacon/src/jsonrpc.rs

@@ -97,6 +97,19 @@ async fn complete_request(network: Arc<BeaconNetwork>, request: BeaconJsonRpcReq
                 None => Err("Beacon client not initialized".to_string()),
             }
         }
+        BeaconEndpoint::FinalizedStateRoot => {
+            let beacon_client = network.beacon_client.lock().await;
+            match beacon_client.as_ref() {
+                Some(client) => {
+                    let header = client.get_finalized_header().await;
+                    match header {
+                        Ok(header) => Ok(json!((header.state_root))),
+                        Err(err) => Err(err.to_string()),
+                    }
+                }
+                None => Err("Beacon client not initialized".to_string()),
+            }
+        }
     };
     let _ = request.resp.send(response);
 }