(fix) Return false, not null, when not syncing.

(feat) Add testing details to README

Author: rrw-zilliqa

README.md

@@ -103,5 +103,4 @@ Of the currently undocumented APIs, the following are partially implemented:
 
   * `eth_getBlockByHash` (issue #79)
   * `eth_getBlockByNumber` (issue #79)
-  * `eth_syncing`
   * `net_peerCount`

docs/api/eth/eth_syncing.doc.md

@@ -8,7 +8,7 @@ eth,mining
 
 # Description
 
-Returns if the node is mining. zq2 nodes always return `false`.
+Returns if the node is synchronising with the main chain.
 
 # Curl
 
@@ -23,10 +23,22 @@ Returns if the node is mining. zq2 nodes always return `false`.
 
 # Response
 
+If the node is synchronised,
+
 ```
 {"jsonrpc":"2.0","result":false,"id":"1"}
 ```
 
+If the node is not synchronised:
+
+```
+{"jsonrpc":"2.0","id":"1","result":{"startingBlock":0,"currentBlock":24,"highestBlock":1781}}
+```
+
+This tells you that this node started syncing at 0 (we started at
+genesis), has validated and committed block 24 and believes that the
+highest block in the chain is somewhere near block 1781.
+
 # Arguments
 
 | Parameter | Type   | Required | Description     |

z2/docs/README.md

@@ -51,3 +51,9 @@ Each field is a comma-separated list of ranges - eg. `2` or `1,4-5`.
 Thus `1,2,3/` means "Create a network of three validators - nodes 1,2,3 and start none of them".
 
 Ranges are inclusive, so `2-3` means "start validators 2 and 3" - beware of this because internally we convert to the standard Rust half-open ranges.
+
+## Running the js tests against z2 networks
+
+You can run the js tests against z2 networks. See `evm_scilla_js_tests/README.z2.md` for details.
+
+

zilliqa/src/api/eth.rs

@@ -29,7 +29,9 @@ use tracing::*;
 
 use super::{
     to_hex::ToHex,
-    types::eth::{self, CallParams, ErrorCode, HashOrTransaction, OneOrMany, SyncingResult},
+    types::eth::{
+        self, CallParams, ErrorCode, HashOrTransaction, OneOrMany, SyncingResult, SyncingStruct,
+    },
 };
 use crate::{
     crypto::Hash,
@@ -852,18 +854,18 @@ fn protocol_version(_: Params, _: &Arc<Mutex<Node>>) -> Result<String> {
     Ok("0x41".to_string())
 }
 
-fn syncing(params: Params, node: &Arc<Mutex<Node>>) -> Result<Option<SyncingResult>> {
+fn syncing(params: Params, node: &Arc<Mutex<Node>>) -> Result<SyncingResult> {
     expect_end_of_params(&mut params.sequence(), 0, 0)?;
     if let Some((starting_block, current_block, highest_block)) =
         node.lock().unwrap().consensus.get_sync_data()?
     {
-        Ok(Some(SyncingResult {
+        Ok(SyncingResult::Struct(SyncingStruct {
             starting_block,
             current_block,
             highest_block,
         }))
     } else {
-        Ok(None)
+        Ok(SyncingResult::Bool(false))
     }
 }
 

zilliqa/src/api/types/eth.rs

@@ -450,12 +450,19 @@ pub struct TxPoolContent {
 
 #[derive(Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
-pub struct SyncingResult {
+pub struct SyncingStruct {
     pub starting_block: u64,
     pub current_block: u64,
     pub highest_block: u64,
 }
 
+#[derive(Clone, Serialize)]
+#[serde(untagged)]
+pub enum SyncingResult {
+    Bool(bool),
+    Struct(SyncingStruct),
+}
+
 #[cfg(test)]
 mod tests {
     use alloy::primitives::B256;

zilliqa/tests/it/eth.rs

@@ -1359,14 +1359,21 @@ async fn test_send_transaction_errors(mut network: Network) {
     }
 }
 
-#[derive(Clone, Deserialize, Serialize, Debug)]
+#[derive(Clone, Deserialize, Serialize, Debug, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
-pub struct SyncingResult {
+pub struct SyncingStruct {
     pub starting_block: u64,
     pub current_block: u64,
     pub highest_block: u64,
 }
 
+#[derive(Clone, Serialize, Deserialize, Debug, PartialEq, Eq)]
+#[serde(untagged)]
+pub enum SyncingResult {
+    Bool(bool),
+    Struct(SyncingStruct),
+}
+
 #[zilliqa_macros::test]
 async fn test_eth_syncing(mut network: Network) {
     let client = network.rpc_client(0).await.unwrap();
@@ -1379,8 +1386,8 @@ async fn test_eth_syncing(mut network: Network) {
         .await
         .unwrap();
     let result = client
-        .request_optional::<(), Option<SyncingResult>>("eth_syncing", None)
+        .request_optional::<(), SyncingResult>("eth_syncing", None)
         .await
         .unwrap();
-    assert!(result.is_none())
+    assert_eq!(result, SyncingResult::Bool(false))
 }