Add support for cron actor in StateDecodeParams API

Cargo.toml

@@ -68,21 +68,21 @@ educe = { version = "0.6.0", features = ["Debug"], default-features = false }
 enumflags2 = "0.7"
 ethereum-types = { version = "0.15", features = ["ethbloom"] }
 ez-jsonrpc-types = "0.5"
-fil_actor_account_state = { version = "22.2" }
-fil_actor_cron_state = { version = "22.2" }
-fil_actor_datacap_state = { version = "22.2" }
-fil_actor_eam_state = { version = "22.2" }
-fil_actor_evm_state = { version = "22.2" }
-fil_actor_init_state = { version = "22.2" }
-fil_actor_market_state = { version = "22.2" }
-fil_actor_miner_state = { version = "22.2" }
-fil_actor_multisig_state = { version = "22.2" }
-fil_actor_paych_state = { version = "22.2" }
-fil_actor_power_state = { version = "22.2" }
-fil_actor_reward_state = { version = "22.2" }
-fil_actor_system_state = { version = "22.2" }
-fil_actor_verifreg_state = { version = "22.2" }
-fil_actors_shared = { version = "22.2", features = ["json"] }
+fil_actor_account_state = { version = "22.4" }
+fil_actor_cron_state = { version = "22.4" }
+fil_actor_datacap_state = { version = "22.4" }
+fil_actor_eam_state = { version = "22.4" }
+fil_actor_evm_state = { version = "22.4" }
+fil_actor_init_state = { version = "22.4" }
+fil_actor_market_state = { version = "22.4" }
+fil_actor_miner_state = { version = "22.4" }
+fil_actor_multisig_state = { version = "22.4" }
+fil_actor_paych_state = { version = "22.4" }
+fil_actor_power_state = { version = "22.4" }
+fil_actor_reward_state = { version = "22.4" }
+fil_actor_system_state = { version = "22.4" }
+fil_actor_verifreg_state = { version = "22.4" }
+fil_actors_shared = { version = "22.4", features = ["json"] }
 flate2 = "1"
 flume = { workspace = true }
 fs_extra = "1"

src/lotus_json/actor_states/methods/cron_actor_params.rs

@@ -0,0 +1,82 @@
+// Copyright 2019-2025 ChainSafe Systems
+// SPDX-License-Identifier: Apache-2.0, MIT
+
+use super::*;
+use crate::shim::actors::cron::Entry;
+use paste::paste;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize, JsonSchema, Clone)]
+#[serde(rename_all = "PascalCase")]
+pub struct CronConstructorParamsLotusJson {
+    #[schemars(with = "LotusJson<Vec<Entry>>")]
+    #[serde(with = "crate::lotus_json")]
+    pub entries: Vec<Entry>,
+}
+
+macro_rules! impl_lotus_json_for_cron_constructor_params {
+    ($($version:literal),+) => {
+        $(
+            paste! {
+                impl HasLotusJson for fil_actor_cron_state::[<v $version>]::ConstructorParams {
+                    type LotusJson = CronConstructorParamsLotusJson;
+
+                    #[cfg(test)]
+                    fn snapshots() -> Vec<(serde_json::Value, Self)> {
+                        use crate::shim::address::Address;
+                        vec![(
+                            json!({
+                                "Entries": [
+                                    {
+                                        "Receiver": "f01",
+                                        "MethodNum": 2
+                                    },
+                                    {
+                                        "Receiver": "f02",
+                                        "MethodNum": 3
+                                    }
+                                ]
+                            }),
+                            Self {
+                                entries: vec![
+                                    fil_actor_cron_state::[<v $version>]::Entry {
+                                        receiver: Address::new_id(1).into(),
+                                        method_num: 2,
+                                    },
+                                    fil_actor_cron_state::[<v $version>]::Entry {
+                                        receiver: Address::new_id(2).into(),
+                                        method_num: 3,
+                                    },
+                                ],
+                            },
+                        )]
+                    }
+
+                    fn into_lotus_json(self) -> Self::LotusJson {
+                        Self::LotusJson {
+                            entries: self.entries.into_iter().map(Entry::[<V $version>]).collect(),
+                        }
+                    }
+
+                    fn from_lotus_json(json: Self::LotusJson) -> Self {
+                        Self {
+                            entries: json.entries.into_iter().map(|entry| match entry {
+                                Entry::[<V $version>](e) => e,
+                                _ => {
+                                    let lotus_entry = entry.into_lotus_json();
+                                    fil_actor_cron_state::[<v $version>]::Entry {
+                                        receiver: lotus_entry.receiver.into(),
+                                        method_num: lotus_entry.method_num,
+                                    }
+                                }
+                            }).collect(),
+                        }
+                    }
+                }
+            }
+        )+
+    };
+}
+
+impl_lotus_json_for_cron_constructor_params!(8, 9, 10, 11, 12, 13, 14, 15, 16);

src/lotus_json/actor_states/methods/mod.rs

@@ -3,6 +3,7 @@
 use super::*;
 mod account_authenticate_params;
 mod account_constructor_params;
+mod cron_actor_params;
 mod datacap_actor_params;
 mod evm_constructor_params;
 mod init_constructor_params;

src/rpc/registry/actors/cron.rs

@@ -0,0 +1,37 @@
+// Copyright 2019-2025 ChainSafe Systems
+// SPDX-License-Identifier: Apache-2.0, MIT
+
+use crate::rpc::registry::methods_reg::{MethodRegistry, register_actor_methods};
+use crate::shim::message::MethodNum;
+use anyhow::Result;
+use cid::Cid;
+
+macro_rules! register_cron_version {
+    ($registry:expr, $code_cid:expr, $state_version:path) => {{
+        use $state_version::{ConstructorParams, Method};
+
+        register_actor_methods!(
+            $registry,
+            $code_cid,
+            [(Method::Constructor, ConstructorParams),]
+        );
+
+        // Register methods with empty params
+        register_actor_methods!($registry, $code_cid, [(Method::EpochTick, empty),]);
+    }};
+}
+
+pub(crate) fn register_actor_methods(registry: &mut MethodRegistry, cid: Cid, version: u64) {
+    match version {
+        8 => register_cron_version!(registry, cid, fil_actor_cron_state::v8),
+        9 => register_cron_version!(registry, cid, fil_actor_cron_state::v9),
+        10 => register_cron_version!(registry, cid, fil_actor_cron_state::v10),
+        11 => register_cron_version!(registry, cid, fil_actor_cron_state::v11),
+        12 => register_cron_version!(registry, cid, fil_actor_cron_state::v12),
+        13 => register_cron_version!(registry, cid, fil_actor_cron_state::v13),
+        14 => register_cron_version!(registry, cid, fil_actor_cron_state::v14),
+        15 => register_cron_version!(registry, cid, fil_actor_cron_state::v15),
+        16 => register_cron_version!(registry, cid, fil_actor_cron_state::v16),
+        _ => {}
+    }
+}

src/rpc/registry/actors/mod.rs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0, MIT
 
 pub(crate) mod account;
+pub(crate) mod cron;
 pub(crate) mod datacap;
 pub(crate) mod evm;
 pub(crate) mod init;

src/rpc/registry/methods_reg.rs

@@ -74,7 +74,7 @@ impl MethodRegistry {
 
     fn register_known_methods(&mut self) {
         use crate::rpc::registry::actors::{
-            account, datacap, evm, init, miner, multisig, power, reward, system,
+            account, cron, datacap, evm, init, miner, multisig, power, reward, system,
         };
 
         for (&cid, &(actor_type, version)) in ACTOR_REGISTRY.iter() {
@@ -91,6 +91,7 @@ impl MethodRegistry {
                 }
                 BuiltinActor::Power => power::register_actor_methods(self, cid, version),
                 BuiltinActor::Reward => reward::register_actor_methods(self, cid, version),
+                BuiltinActor::Cron => cron::register_actor_methods(self, cid, version),
                 BuiltinActor::Multisig => multisig::register_actor_methods(self, cid, version),
                 _ => {}
             }
@@ -261,6 +262,7 @@ mod test {
             BuiltinActor::Account,
             BuiltinActor::Miner,
             BuiltinActor::EVM,
+            BuiltinActor::Cron,
             BuiltinActor::DataCap,
         ];
 

src/tool/subcommands/api_cmd/api_compare_tests.rs

@@ -1897,6 +1897,14 @@ fn state_decode_params_api_tests(tipset: &Tipset) -> anyhow::Result<Vec<RpcTest>
         ))),
     };
 
+    // TODO(go-state-types): https://github.com/filecoin-project/go-state-types/issues/396
+    // Enable this test when lotus supports it in go-state-types.
+    // let cron_constructor_params = fil_actor_cron_state::v16::ConstructorParams {
+    //     entries: vec![fil_actor_cron_state::v16::Entry {
+    //         receiver: Address::new_id(1000).into(),
+    //         method_num: fil_actor_cron_state::v16::Method::EpochTick as u64,
+    //     }],
+    // };
     let multisig_constructor_params = fil_actor_multisig_state::v16::ConstructorParams {
         signers: vec![Address::new_id(1000).into(), Address::new_id(1001).into()],
         num_approvals_threshold: Default::default(),
@@ -2019,6 +2027,20 @@ fn state_decode_params_api_tests(tipset: &Tipset) -> anyhow::Result<Vec<RpcTest>
             to_vec(&power_create_miner_params)?,
             tipset.key().into(),
         ))?),
+        // TODO(go-state-types): https://github.com/filecoin-project/go-state-types/issues/396
+        // Enable this test when lotus supports it in go-state-types.
+        // RpcTest::identity(StateDecodeParams::request((
+        //     Address::CRON_ACTOR,
+        //     fil_actor_cron_state::v16::Method::Constructor as u64,
+        //     to_vec(&cron_constructor_params)?,
+        //     tipset.key().into(),
+        // ))?),
+        RpcTest::identity(StateDecodeParams::request((
+            Address::CRON_ACTOR,
+            fil_actor_cron_state::v16::Method::EpochTick as u64,
+            vec![],
+            tipset.key().into(),
+        ))?),
         RpcTest::identity(StateDecodeParams::request((
             Address::POWER_ACTOR,
             fil_actor_power_state::v16::Method::UpdateClaimedPower as u64,

src/tool/subcommands/api_cmd/test_snapshots.txt

@@ -159,6 +159,7 @@ filecoin_statedecodeparams_1753985928338431.rpcsnap.json.zst
 filecoin_statedecodeparams_1753985928337192.rpcsnap.json.zst
 filecoin_statedecodeparams_1753985928337443.rpcsnap.json.zst
 filecoin_statedecodeparams_1753985928337618.rpcsnap.json.zst
+filecoin_cron_epochtick_statedecodeparams_1754489337228993.rpcsnap.json.zst
 filecoin_power_minercount_statedecodeparams_1754479441718517.rpcsnap.json.zst
 filecoin_system_constructor_statedecodeparams_1754479441718641.rpcsnap.json.zst
 filecoin_power_constructor_statedecodeparams_1754479441718709.rpcsnap.json.zst