parity tests

Author: hanabi1224

src/rpc/client.rs

@@ -14,8 +14,7 @@ use std::fmt::{self, Debug};
 use std::sync::LazyLock;
 use std::time::Duration;
 
-use anyhow::{Context as _, bail};
-use enumflags2::BitFlags;
+use anyhow::bail;
 use futures::future::Either;
 use http::{HeaderMap, HeaderValue, header};
 use jsonrpsee::core::ClientError;
@@ -93,15 +92,17 @@ impl Client {
         &self,
         req: Request<T>,
     ) -> Result<T, ClientError> {
+        let max_api_path = req
+            .api_path()
+            .map_err(|e| ClientError::Custom(e.to_string()))?;
         let Request {
             method_name,
             params,
-            api_paths,
             timeout,
             ..
         } = req;
         let method_name = method_name.as_ref();
-        let client = self.get_or_init_client(api_paths).await?;
+        let client = self.get_or_init_client(max_api_path).await?;
         let span = tracing::debug_span!("request", method = %method_name, url = %client.url);
         let work = async {
             // jsonrpsee's clients have a global `timeout`, but not a per-request timeout, which
@@ -149,31 +150,16 @@ impl Client {
         };
         work.instrument(span.or_current()).await
     }
-    async fn get_or_init_client(
-        &self,
-        version: BitFlags<ApiPaths>,
-    ) -> Result<&UrlClient, ClientError> {
-        let path = version
-            .iter()
-            .max()
-            .context("No supported versions")
-            .map_err(|e| ClientError::Custom(e.to_string()))?;
+    async fn get_or_init_client(&self, path: ApiPaths) -> Result<&UrlClient, ClientError> {
         match path {
             ApiPaths::V0 => &self.v0,
             ApiPaths::V1 => &self.v1,
             ApiPaths::V2 => &self.v2,
         }
         .get_or_try_init(|| async {
-            let url = self
-                .base_url
-                .join(match path {
-                    ApiPaths::V0 => "rpc/v0",
-                    ApiPaths::V1 => "rpc/v1",
-                    ApiPaths::V2 => "rpc/v2",
-                })
-                .map_err(|it| {
-                    ClientError::Custom(format!("creating url for endpoint failed: {it}"))
-                })?;
+            let url = self.base_url.join(path.path()).map_err(|it| {
+                ClientError::Custom(format!("creating url for endpoint failed: {it}"))
+            })?;
             UrlClient::new(url, self.token.clone()).await
         })
         .await

src/rpc/methods/chain.rs

@@ -1,7 +1,7 @@
 // Copyright 2019-2025 ChainSafe Systems
 // SPDX-License-Identifier: Apache-2.0, MIT
 
-mod types;
+pub mod types;
 use enumflags2::{BitFlags, make_bitflags};
 use types::*;
 

src/rpc/methods/chain/types.rs

@@ -3,6 +3,9 @@
 
 use super::*;
 
+#[cfg(test)]
+mod tests;
+
 #[derive(Serialize, Deserialize, JsonSchema, Clone, Debug, Eq, PartialEq, Default)]
 #[serde(rename_all = "PascalCase")]
 pub struct ObjStat {
@@ -11,14 +14,18 @@ pub struct ObjStat {
 }
 lotus_json_with_self!(ObjStat);
 
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
 pub struct TipsetSelector {
-    #[serde(with = "crate::lotus_json")]
+    #[serde(
+        with = "crate::lotus_json",
+        skip_serializing_if = "ApiTipsetKey::is_none",
+        default
+    )]
     #[schemars(with = "LotusJson<TipsetKey>")]
     pub key: ApiTipsetKey,
-    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none", default)]
     pub height: Option<TipsetHeight>,
-    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none", default)]
     pub tag: Option<TipsetTag>,
 }
 lotus_json_with_self!(TipsetSelector);
@@ -49,7 +56,7 @@ impl TipsetSelector {
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
 pub struct TipsetHeight {
     pub at: ChainEpoch,
     pub previous: bool,
@@ -83,7 +90,7 @@ impl TipsetHeight {
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
 pub struct TipsetAnchor {
     #[serde(with = "crate::lotus_json")]
     #[schemars(with = "LotusJson<TipsetKey>")]
@@ -109,9 +116,19 @@ impl TipsetAnchor {
 }
 
 #[derive(
-    Debug, Clone, Copy, strum::Display, strum::EnumString, Serialize, Deserialize, JsonSchema,
+    Debug,
+    Clone,
+    Copy,
+    strum::Display,
+    strum::EnumString,
+    Serialize,
+    Deserialize,
+    PartialEq,
+    Eq,
+    JsonSchema,
 )]
 #[strum(serialize_all = "lowercase")]
+#[serde(rename_all = "lowercase")]
 pub enum TipsetTag {
     Latest,
     Finalized,

src/rpc/methods/chain/types/tests.rs

@@ -0,0 +1,17 @@
+// Copyright 2019-2025 ChainSafe Systems
+// SPDX-License-Identifier: Apache-2.0, MIT
+
+use super::*;
+
+#[test]
+fn test_tipset_selector_serde() {
+    let s = TipsetSelector {
+        key: None.into(),
+        height: None,
+        tag: None,
+    };
+    let json = serde_json::to_value(&s).unwrap();
+    println!("{json}");
+    let s2: TipsetSelector = serde_json::from_value(json).unwrap();
+    assert_eq!(s, s2);
+}

src/rpc/reflect/mod.rs

@@ -162,6 +162,14 @@ impl ApiPaths {
             uri.path().split("/").last().expect("infallible"),
         )?)
     }
+
+    pub fn path(&self) -> &'static str {
+        match self {
+            Self::V0 => "rpc/v0",
+            Self::V1 => "rpc/v1",
+            Self::V2 => "rpc/v2",
+        }
+    }
 }
 
 /// Utility methods, defined as an extension trait to avoid having to specify

src/rpc/request.rs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0, MIT
 
 use super::ApiPaths;
+use anyhow::Context as _;
 use enumflags2::BitFlags;
 use jsonrpsee::core::traits::ToRpcParams;
 use serde::{Deserialize, Serialize};
@@ -41,6 +42,14 @@ impl<T> Request<T> {
             timeout: self.timeout,
         }
     }
+
+    pub fn max_api_path(api_paths: BitFlags<ApiPaths>) -> anyhow::Result<ApiPaths> {
+        api_paths.iter().max().context("No supported versions")
+    }
+
+    pub fn api_path(&self) -> anyhow::Result<ApiPaths> {
+        Self::max_api_path(self.api_paths)
+    }
 }
 
 impl<T> ToRpcParams for Request<T> {

src/rpc/types/mod.rs

@@ -157,7 +157,15 @@ lotus_json_with_self!(MessageLookup);
     derive_more::From,
     derive_more::Into,
 )]
-pub struct ApiTipsetKey(pub Option<TipsetKey>);
+pub struct ApiTipsetKey(
+    #[serde(skip_serializing_if = "Option::is_none", default)] pub Option<TipsetKey>,
+);
+
+impl ApiTipsetKey {
+    pub fn is_none(&self) -> bool {
+        self.0.is_none()
+    }
+}
 
 /// This wrapper is needed because of a bug in Lotus.
 /// See: <https://github.com/filecoin-project/lotus/issues/11461>.

src/tool/subcommands/api_cmd.rs

@@ -14,9 +14,7 @@ use crate::db::db_engine::db_root;
 use crate::eth::EthChainId as EthChainIdType;
 use crate::lotus_json::HasLotusJson;
 use crate::networks::NetworkChain;
-use crate::rpc;
-use crate::rpc::eth::types::*;
-use crate::rpc::prelude::*;
+use crate::rpc::{self, ApiPaths, eth::types::*, prelude::*};
 use crate::shim::address::Address;
 use crate::tool::offline_server::start_offline_server;
 use crate::tool::subcommands::api_cmd::stateful_tests::TestTransaction;
@@ -122,6 +120,9 @@ pub enum ApiCommands {
         /// Empty lines and lines starting with `#` are ignored.
         #[arg(long)]
         filter_file: Option<PathBuf>,
+        /// Filter methods for the specific API version.
+        #[arg(long)]
+        filter_version: Option<ApiPaths>,
         /// Cancel test run on the first failure
         #[arg(long)]
         fail_fast: bool,
@@ -285,6 +286,7 @@ impl ApiCommands {
                 lotus: UrlFromMultiAddr(lotus),
                 filter,
                 filter_file,
+                filter_version,
                 fail_fast,
                 run_ignored,
                 max_concurrent_requests,
@@ -300,16 +302,17 @@ impl ApiCommands {
 
                 api_compare_tests::run_tests(
                     tests,
-                    forest.clone(),
-                    lotus.clone(),
+                    forest,
+                    lotus,
                     max_concurrent_requests,
-                    filter_file.clone(),
-                    filter.clone(),
+                    filter_file,
+                    filter,
+                    filter_version,
                     run_ignored,
                     fail_fast,
-                    dump_dir.clone(),
+                    dump_dir,
                     &test_criteria_overrides,
-                    report_dir.clone(),
+                    report_dir,
                     report_mode,
                 )
                 .await?;
@@ -366,8 +369,7 @@ impl ApiCommands {
                                     },
                                     index,
                                     db,
-                                    // https://github.com/ChainSafe/forest/issues/6220
-                                    api_path: None,
+                                    api_path: Some(test_dump.path),
                                 }
                             };