Switch block reporting changes (#261)

* Switch block reporting changes

* Correct typo in name

* Bump types

resources/test/rpc_schema.json

@@ -1312,6 +1312,17 @@
             "block_sync": {
               "description": "The status of the block synchronizer builders.",
               "$ref": "#/components/schemas/BlockSynchronizerStatus"
+            },
+            "latest_switch_block_hash": {
+              "description": "The hash of the latest switch block.",
+              "anyOf": [
+                {
+                  "$ref": "#/components/schemas/BlockHash"
+                },
+                {
+                  "type": "null"
+                }
+              ]
             }
           },
           "additionalProperties": false
@@ -1366,7 +1377,8 @@
                   "block_height": 6701,
                   "acquisition_state": "have block body(6701) for: block hash 5990..4983"
                 }
-              }
+              },
+              "latest_switch_block_hash": "0000000000000000000000000000000000000000000000000000000000000000"
             }
           }
         }

resources/test/schema_status.json

@@ -123,6 +123,17 @@
           "$ref": "#/definitions/BlockSynchronizerStatus"
         }
       ]
+    },
+    "latest_switch_block_hash": {
+      "description": "The hash of the latest switch block.",
+      "anyOf": [
+        {
+          "$ref": "#/definitions/BlockHash"
+        },
+        {
+          "type": "null"
+        }
+      ]
     }
   },
   "additionalProperties": false,

rpc_sidecar/src/node_client.rs

@@ -195,6 +195,13 @@ pub trait NodeClient: Send + Sync {
         parse_response::<ConsensusValidatorChanges>(&resp.into())?.ok_or(Error::EmptyEnvelope)
     }
 
+    async fn read_latest_switch_block_header(&self) -> Result<Option<BlockHeader>, Error> {
+        let resp = self
+            .read_info(InformationRequest::LatestSwitchBlockHeader)
+            .await?;
+        parse_response::<BlockHeader>(&resp.into())
+    }
+
     async fn read_node_status(&self) -> Result<NodeStatus, Error> {
         let resp = self.read_info(InformationRequest::NodeStatus).await?;
         parse_response::<NodeStatus>(&resp.into())?.ok_or(Error::EmptyEnvelope)

rpc_sidecar/src/rpcs/chain.rs

@@ -275,8 +275,12 @@ impl RpcWithOptionalParams for GetEraInfoBySwitchBlock {
         node_client: Arc<dyn NodeClient>,
         maybe_params: Option<Self::OptionalRequestParams>,
     ) -> Result<Self::ResponseResult, RpcError> {
-        let identifier = maybe_params.map(|params| params.block_identifier);
-        let block_header = common::get_block_header(&*node_client, identifier).await?;
+        let block_header = match maybe_params {
+            Some(params) => {
+                common::get_block_header(&*node_client, Some(params.block_identifier)).await?
+            }
+            None => common::get_latest_switch_block_header(&*node_client).await?,
+        };
         let era_summary = if block_header.is_switch_block() {
             Some(get_era_summary_by_block(node_client, &block_header).await?)
         } else {
@@ -334,8 +338,13 @@ impl RpcWithOptionalParams for GetEraSummary {
         node_client: Arc<dyn NodeClient>,
         maybe_params: Option<Self::OptionalRequestParams>,
     ) -> Result<Self::ResponseResult, RpcError> {
-        let identifier = maybe_params.map(|params| params.block_identifier);
-        let block_header = common::get_block_header(&*node_client, identifier).await?;
+        let block_header = match maybe_params {
+            Some(params) => {
+                common::get_block_header(&*node_client, Some(params.block_identifier)).await?
+            }
+            None => common::get_latest_switch_block_header(&*node_client).await?,
+        };
+
         let era_summary = get_era_summary_by_block(node_client, &block_header).await?;
 
         Ok(Self::ResponseResult {
@@ -547,6 +556,7 @@ mod tests {
         let resp = GetEraSummary::do_handle_request(
             Arc::new(ValidEraSummaryMock {
                 block: Block::V2(block.clone()),
+                expect_no_block_identifier: true,
             }),
             None,
         )
@@ -568,6 +578,38 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn should_read_block_era_summary_with_block_id() {
+        let rng = &mut TestRng::new();
+        let block = TestBlockBuilder::new().build(rng);
+
+        let resp = GetEraSummary::do_handle_request(
+            Arc::new(ValidEraSummaryMock {
+                block: Block::V2(block.clone()),
+                expect_no_block_identifier: false,
+            }),
+            Some(GetEraSummaryParams {
+                block_identifier: BlockIdentifier::Hash(*block.hash()),
+            }),
+        )
+        .await
+        .expect("should handle request");
+
+        assert_eq!(
+            resp,
+            GetEraSummaryResult {
+                api_version: CURRENT_API_VERSION,
+                era_summary: EraSummary {
+                    block_hash: *block.hash(),
+                    era_id: block.era_id(),
+                    stored_value: StoredValue::EraInfo(EraInfo::new()),
+                    state_root_hash: *block.state_root_hash(),
+                    merkle_proof: String::from("00000000"),
+                }
+            }
+        );
+    }
+
     #[tokio::test]
     async fn should_read_block_era_info_by_switch_block() {
         let rng = &mut TestRng::new();
@@ -576,6 +618,7 @@ mod tests {
         let resp = GetEraInfoBySwitchBlock::do_handle_request(
             Arc::new(ValidEraSummaryMock {
                 block: Block::V2(block.clone()),
+                expect_no_block_identifier: true,
             }),
             None,
         )
@@ -597,6 +640,38 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn should_read_block_era_info_by_switch_block_with_block_id() {
+        let rng = &mut TestRng::new();
+        let block = TestBlockBuilder::new().switch_block(true).build(rng);
+
+        let resp = GetEraInfoBySwitchBlock::do_handle_request(
+            Arc::new(ValidEraSummaryMock {
+                block: Block::V2(block.clone()),
+                expect_no_block_identifier: false,
+            }),
+            Some(GetEraInfoParams {
+                block_identifier: BlockIdentifier::Hash(*block.hash()),
+            }),
+        )
+        .await
+        .expect("should handle request");
+
+        assert_eq!(
+            resp,
+            GetEraInfoResult {
+                api_version: CURRENT_API_VERSION,
+                era_summary: Some(EraSummary {
+                    block_hash: *block.hash(),
+                    era_id: block.era_id(),
+                    stored_value: StoredValue::EraInfo(EraInfo::new()),
+                    state_root_hash: *block.state_root_hash(),
+                    merkle_proof: String::from("00000000"),
+                })
+            }
+        );
+    }
+
     #[tokio::test]
     async fn should_read_none_block_era_info_by_switch_block_for_non_switch() {
         let rng = &mut TestRng::new();
@@ -605,6 +680,7 @@ mod tests {
         let resp = GetEraInfoBySwitchBlock::do_handle_request(
             Arc::new(ValidEraSummaryMock {
                 block: Block::V2(block.clone()),
+                expect_no_block_identifier: true,
             }),
             None,
         )
@@ -669,6 +745,7 @@ mod tests {
 
     struct ValidEraSummaryMock {
         block: Block,
+        expect_no_block_identifier: bool,
     }
 
     #[async_trait]
@@ -677,10 +754,14 @@ mod tests {
             &self,
             req: BinaryRequest,
         ) -> Result<BinaryResponseAndRequest, ClientError> {
+            let expected_tag = if self.expect_no_block_identifier {
+                InformationRequestTag::LatestSwitchBlockHeader
+            } else {
+                InformationRequestTag::BlockHeader
+            };
             match req {
                 BinaryRequest::Get(GetRequest::Information { info_type_tag, .. })
-                    if InformationRequestTag::try_from(info_type_tag)
-                        == Ok(InformationRequestTag::BlockHeader) =>
+                    if InformationRequestTag::try_from(info_type_tag) == Ok(expected_tag) =>
                 {
                     Ok(BinaryResponseAndRequest::new(
                         BinaryResponse::from_value(

rpc_sidecar/src/rpcs/common.rs

@@ -91,6 +91,25 @@ pub async fn get_block_header(
     }
 }
 
+pub async fn get_latest_switch_block_header(
+    node_client: &dyn NodeClient,
+) -> Result<BlockHeader, Error> {
+    match node_client
+        .read_latest_switch_block_header()
+        .await
+        .map_err(|err| Error::NodeRequest("latest switch block header", err))?
+    {
+        Some(header) => Ok(header),
+        None => {
+            let available_range = node_client
+                .read_available_block_range()
+                .await
+                .map_err(|err| Error::NodeRequest("available block range", err))?;
+            Err(Error::NoBlockFound(None, available_range))
+        }
+    }
+}
+
 pub async fn resolve_account_hash(
     node_client: &dyn NodeClient,
     account_hash: AccountHash,

rpc_sidecar/src/rpcs/info.rs

@@ -10,9 +10,9 @@ use serde::{Deserialize, Serialize};
 use casper_types::{
     binary_port::MinimalBlockInfo,
     execution::{ExecutionResult, ExecutionResultV2},
-    ActivationPoint, AvailableBlockRange, Block, BlockSynchronizerStatus, ChainspecRawBytes,
-    Deploy, DeployHash, Digest, EraId, ExecutionInfo, NextUpgrade, Peers, ProtocolVersion,
-    PublicKey, TimeDiff, Timestamp, Transaction, TransactionHash, ValidatorChange,
+    ActivationPoint, AvailableBlockRange, Block, BlockHash, BlockSynchronizerStatus,
+    ChainspecRawBytes, Deploy, DeployHash, Digest, EraId, ExecutionInfo, NextUpgrade, Peers,
+    ProtocolVersion, PublicKey, TimeDiff, Timestamp, Transaction, TransactionHash, ValidatorChange,
 };
 
 use super::{
@@ -84,6 +84,7 @@ static GET_STATUS_RESULT: Lazy<GetStatusResult> = Lazy::new(|| GetStatusResult {
     last_progress: Timestamp::from(0),
     available_block_range: AvailableBlockRange::RANGE_0_0,
     block_sync: BlockSynchronizerStatus::example().clone(),
+    latest_switch_block_hash: Some(BlockHash::default()),
     #[cfg(not(test))]
     build_version: version_string(),
 
@@ -450,6 +451,8 @@ pub struct GetStatusResult {
     pub available_block_range: AvailableBlockRange,
     /// The status of the block synchronizer builders.
     pub block_sync: BlockSynchronizerStatus,
+    /// The hash of the latest switch block.
+    pub latest_switch_block_hash: Option<BlockHash>,
 }
 
 impl DocExample for GetStatusResult {
@@ -488,6 +491,7 @@ impl RpcWithoutParams for GetStatus {
             last_progress: status.last_progress,
             available_block_range: status.available_block_range,
             block_sync: status.block_sync,
+            latest_switch_block_hash: status.latest_switch_block_hash,
             build_version: status.build_version,
         })
     }