diff --git a/src/lotus_json/actor_states/methods/mod.rs b/src/lotus_json/actor_states/methods/mod.rs index 825949dbe75f..1f5067dfd572 100644 --- a/src/lotus_json/actor_states/methods/mod.rs +++ b/src/lotus_json/actor_states/methods/mod.rs @@ -9,3 +9,4 @@ mod init_exec4_params; mod init_exec_params; mod miner_change_worker_params; mod miner_constructor_params; +mod power_actor; diff --git a/src/lotus_json/actor_states/methods/power_actor.rs b/src/lotus_json/actor_states/methods/power_actor.rs new file mode 100644 index 000000000000..faea44701b5f --- /dev/null +++ b/src/lotus_json/actor_states/methods/power_actor.rs @@ -0,0 +1,321 @@ +// Copyright 2019-2025 ChainSafe Systems +// SPDX-License-Identifier: Apache-2.0, MIT + +use super::*; +use crate::shim::address::Address; +use crate::shim::clock::ChainEpoch; +use crate::shim::econ::TokenAmount; +use crate::shim::sector::RegisteredPoStProof; +use fvm_ipld_encoding::{BytesDe, RawBytes}; +use fvm_shared4::ActorID; +use num::BigInt; +use paste::paste; +use serde::{Deserialize, Serialize}; + +#[derive(Serialize, Deserialize, JsonSchema, Debug, Clone, PartialEq)] +#[serde(rename_all = "PascalCase")] +pub struct CreateMinerParamsLotusJson { + #[schemars(with = "LotusJson
")] + #[serde(with = "crate::lotus_json")] + pub owner: Address, + #[schemars(with = "LotusJson
")] + #[serde(with = "crate::lotus_json")] + pub worker: Address, + #[schemars(with = "LotusJson")] + #[serde(with = "crate::lotus_json")] + pub window_po_st_proof_type: RegisteredPoStProof, + #[schemars(with = "LotusJson>")] + #[serde(with = "crate::lotus_json")] + pub peer: Vec, + #[schemars(with = "LotusJson>>")] + #[serde(with = "crate::lotus_json")] + pub multiaddrs: Vec>, +} + +#[derive(Serialize, Deserialize, JsonSchema, Debug, Clone, PartialEq)] +#[serde(rename_all = "PascalCase")] +pub struct UpdateClaimedPowerParamsLotusJson { + #[schemars(with = "LotusJson")] + #[serde(with = "crate::lotus_json")] + pub raw_byte_delta: BigInt, + #[schemars(with = "LotusJson")] + #[serde(with = "crate::lotus_json")] + pub quality_adjusted_delta: BigInt, +} + +#[derive(Serialize, Deserialize, JsonSchema, Debug, Clone, PartialEq)] +#[serde(rename_all = "PascalCase")] +pub struct EnrollCronEventParamsLotusJson { + #[schemars(with = "LotusJson")] + #[serde(with = "crate::lotus_json")] + pub event_epoch: ChainEpoch, + #[schemars(with = "LotusJson")] + #[serde(with = "crate::lotus_json")] + pub payload: RawBytes, +} + +#[derive(Serialize, Deserialize, JsonSchema, Debug, Clone, PartialEq)] +#[serde(rename_all = "PascalCase")] +pub struct UpdatePledgeTotalParamsLotusJson( + #[schemars(with = "LotusJson")] + #[serde(with = "crate::lotus_json")] + TokenAmount, +); + +#[derive(Serialize, Deserialize, JsonSchema, Debug, Clone, PartialEq)] +#[serde(rename_all = "PascalCase")] +pub struct MinerRawPowerParamsLotusJson(ActorID); + +#[derive(Serialize, Deserialize, JsonSchema, Debug, Clone, PartialEq)] +#[serde(rename_all = "PascalCase")] +pub struct MinerPowerParamsLotusJson { + #[schemars(with = "LotusJson")] + #[serde(with = "crate::lotus_json")] + pub miner: ActorID, +} + +// Implementations for CreateMinerParams +macro_rules! impl_lotus_json_for_power_create_miner_params { + ($($version:literal),+) => { + $( + paste! { + impl HasLotusJson for fil_actor_power_state::[]::CreateMinerParams { + type LotusJson = CreateMinerParamsLotusJson; + + #[cfg(test)] + fn snapshots() -> Vec<(serde_json::Value, Self)> { + vec![ + ( + json!({ + "Owner": "f01234", + "Worker": "f01235", + "WindowPostProofType": 1, + "Peer": "AQ==", + "Multiaddrs": ["Ag==", "Aw=="], + }), + Self { + owner: Address::new_id(1234).into(), + worker: Address::new_id(1235).into(), + window_post_proof_type: RegisteredPoStProof::from(fvm_shared4::sector::RegisteredPoStProof::StackedDRGWindow2KiBV1P1).into(), + peer: vec![1], + multiaddrs: vec![], + }, + ), + ] + } + + fn into_lotus_json(self) -> Self::LotusJson { + CreateMinerParamsLotusJson { + owner: self.owner.into(), + worker: self.worker.into(), + window_po_st_proof_type: self.window_post_proof_type.into(), + peer: self.peer, + multiaddrs: self.multiaddrs.into_iter().map(|addr| addr.0).collect(), + } + } + + fn from_lotus_json(lotus_json: Self::LotusJson) -> Self { + Self { + owner: lotus_json.owner.into(), + worker: lotus_json.worker.into(), + window_post_proof_type: lotus_json.window_po_st_proof_type.into(), + peer: lotus_json.peer, + multiaddrs: lotus_json.multiaddrs.into_iter().map(BytesDe).collect(), + } + } + } + } + )+ + }; +} + +// Implementations for UpdateClaimedPowerParams +macro_rules! impl_lotus_json_for_power_update_claimed_power_params { + ($($version:literal),+) => { + $( + paste! { + impl HasLotusJson for fil_actor_power_state::[]::UpdateClaimedPowerParams { + type LotusJson = UpdateClaimedPowerParamsLotusJson; + + #[cfg(test)] + fn snapshots() -> Vec<(serde_json::Value, Self)> { + vec![ + ( + json!({ + "RawByteDelta": "1024", + "QualityAdjustedDelta": "2048", + }), + Self { + raw_byte_delta: crate::shim::sector::StoragePower::from(1024u64), + quality_adjusted_delta: crate::shim::sector::StoragePower::from(2048u64), + }, + ), + ] + } + + fn into_lotus_json(self) -> Self::LotusJson { + UpdateClaimedPowerParamsLotusJson { + raw_byte_delta: self.raw_byte_delta, + quality_adjusted_delta: self.quality_adjusted_delta, + } + } + + fn from_lotus_json(lotus_json: Self::LotusJson) -> Self { + Self { + raw_byte_delta: lotus_json.raw_byte_delta, + quality_adjusted_delta: lotus_json.quality_adjusted_delta, + } + } + } + } + )+ + }; +} + +// Implementations for EnrollCronEventParams +macro_rules! impl_lotus_json_for_power_enroll_cron_event_params { + ($($version:literal),+) => { + $( + paste! { + impl HasLotusJson for fil_actor_power_state::[]::EnrollCronEventParams { + type LotusJson = EnrollCronEventParamsLotusJson; + + #[cfg(test)] + fn snapshots() -> Vec<(serde_json::Value, Self)> { + vec![ + ( + json!({ + "EventEpoch": 12345, + "Payload": "ESIzRFU=", + }), + Self { + event_epoch: 12345, + payload: RawBytes::new(hex::decode("1122334455").unwrap()), + }, + ), + ] + } + + fn into_lotus_json(self) -> Self::LotusJson { + EnrollCronEventParamsLotusJson { + event_epoch: self.event_epoch, + payload: self.payload, + } + } + + fn from_lotus_json(lotus_json: Self::LotusJson) -> Self { + Self { + event_epoch: lotus_json.event_epoch, + payload: lotus_json.payload, + } + } + } + } + )+ + }; +} + +// Implementations for UpdatePledgeTotalParams +macro_rules! impl_lotus_json_for_power_update_pledge_total_params { + ($($version:literal),+) => { + $( + paste! { + impl HasLotusJson for fil_actor_power_state::[]::UpdatePledgeTotalParams { + type LotusJson = UpdatePledgeTotalParamsLotusJson; + + #[cfg(test)] + fn snapshots() -> Vec<(serde_json::Value, Self)> { + vec![ + ( + json!({ + "PledgeDelta": "1000000000000000000", + }), + Self { + pledge_delta: TokenAmount::from_atto(1000000000000000000u64).into(), + }, + ), + ] + } + + fn into_lotus_json(self) -> Self::LotusJson { + UpdatePledgeTotalParamsLotusJson(self.pledge_delta.into()) + } + + fn from_lotus_json(lotus_json: Self::LotusJson) -> Self { + Self { + pledge_delta: lotus_json.0.into(), + } + } + } + } + )+ + }; +} + +// Implementations for MinerRawPowerParams +macro_rules! impl_lotus_json_for_power_miner_raw_power_params { + ($($version:literal),+) => { + $( + paste! { + impl HasLotusJson for fil_actor_power_state::[]::MinerRawPowerParams { + type LotusJson = MinerRawPowerParamsLotusJson; + + #[cfg(test)] + fn snapshots() -> Vec<(serde_json::Value, Self)> { + vec![ + ( + json!({ + "Miner": 1001, + }), + Self { + miner: 1001, + }, + ), + ] + } + + fn into_lotus_json(self) -> Self::LotusJson { + MinerRawPowerParamsLotusJson(self.miner) + } + + fn from_lotus_json(lotus_json: Self::LotusJson) -> Self { + Self { + miner: lotus_json.0, + } + } + } + } + )+ + }; +} + +// Implementations for MinerPowerParams (only present in the power actor v16) +impl HasLotusJson for fil_actor_power_state::v16::MinerPowerParams { + type LotusJson = MinerPowerParamsLotusJson; + + #[cfg(test)] + fn snapshots() -> Vec<(serde_json::Value, Self)> { + vec![( + json!({ + "Miner": 1002, + }), + Self { miner: 1002 }, + )] + } + + fn into_lotus_json(self) -> Self::LotusJson { + MinerPowerParamsLotusJson { miner: self.miner } + } + + fn from_lotus_json(lotus_json: Self::LotusJson) -> Self { + Self { + miner: lotus_json.miner, + } + } +} + +impl_lotus_json_for_power_create_miner_params!(8, 9, 10, 11, 12, 13, 14, 15, 16); +impl_lotus_json_for_power_update_claimed_power_params!(8, 9, 10, 11, 12, 13, 14, 15, 16); +impl_lotus_json_for_power_enroll_cron_event_params!(8, 9, 10, 11, 12, 13, 14, 15, 16); +impl_lotus_json_for_power_update_pledge_total_params!(10, 11, 12, 13, 14, 15, 16); +impl_lotus_json_for_power_miner_raw_power_params!(10, 11, 12, 13, 14, 15, 16); diff --git a/src/rpc/registry/actors/account.rs b/src/rpc/registry/actors/account.rs index 1c4e6d7b34aa..d44574645293 100644 --- a/src/rpc/registry/actors/account.rs +++ b/src/rpc/registry/actors/account.rs @@ -44,11 +44,18 @@ macro_rules! register_account_version { } // register account actor methods, cid is unique for each version of the actor -pub(crate) fn register_account_actor_methods(registry: &mut MethodRegistry, cid: Cid) { - register_account_version!(registry, cid, fil_actor_account_state::v11); - register_account_version!(registry, cid, fil_actor_account_state::v12); - register_account_version!(registry, cid, fil_actor_account_state::v13); - register_account_version!(registry, cid, fil_actor_account_state::v14); - register_account_version!(registry, cid, fil_actor_account_state::v15, with_types); - register_account_version!(registry, cid, fil_actor_account_state::v16, with_types); +pub(crate) fn register_account_actor_methods( + registry: &mut MethodRegistry, + cid: Cid, + version: u64, +) { + match version { + 11 => register_account_version!(registry, cid, fil_actor_account_state::v11), + 12 => register_account_version!(registry, cid, fil_actor_account_state::v12), + 13 => register_account_version!(registry, cid, fil_actor_account_state::v13), + 14 => register_account_version!(registry, cid, fil_actor_account_state::v14), + 15 => register_account_version!(registry, cid, fil_actor_account_state::v15, with_types), + 16 => register_account_version!(registry, cid, fil_actor_account_state::v16, with_types), + _ => {} + } } diff --git a/src/rpc/registry/actors/evm.rs b/src/rpc/registry/actors/evm.rs index f952b610ab0e..618093c5d731 100644 --- a/src/rpc/registry/actors/evm.rs +++ b/src/rpc/registry/actors/evm.rs @@ -18,12 +18,15 @@ macro_rules! register_evm_version { }}; } -pub(crate) fn register_evm_actor_methods(registry: &mut MethodRegistry, cid: Cid) { - register_evm_version!(registry, cid, fil_actor_evm_state::v10); - register_evm_version!(registry, cid, fil_actor_evm_state::v11); - register_evm_version!(registry, cid, fil_actor_evm_state::v12); - register_evm_version!(registry, cid, fil_actor_evm_state::v13); - register_evm_version!(registry, cid, fil_actor_evm_state::v14); - register_evm_version!(registry, cid, fil_actor_evm_state::v15); - register_evm_version!(registry, cid, fil_actor_evm_state::v16); +pub(crate) fn register_evm_actor_methods(registry: &mut MethodRegistry, cid: Cid, version: u64) { + match version { + 10 => register_evm_version!(registry, cid, fil_actor_evm_state::v10), + 11 => register_evm_version!(registry, cid, fil_actor_evm_state::v11), + 12 => register_evm_version!(registry, cid, fil_actor_evm_state::v12), + 13 => register_evm_version!(registry, cid, fil_actor_evm_state::v13), + 14 => register_evm_version!(registry, cid, fil_actor_evm_state::v14), + 15 => register_evm_version!(registry, cid, fil_actor_evm_state::v15), + 16 => register_evm_version!(registry, cid, fil_actor_evm_state::v16), + _ => {} + } } diff --git a/src/rpc/registry/actors/init.rs b/src/rpc/registry/actors/init.rs index 7d1ae8d7dca0..18939c822b2c 100644 --- a/src/rpc/registry/actors/init.rs +++ b/src/rpc/registry/actors/init.rs @@ -5,55 +5,51 @@ use crate::rpc::registry::methods_reg::{MethodRegistry, register_actor_methods}; use crate::shim::message::MethodNum; use anyhow::Result; use cid::Cid; -use paste::paste; // Macro for versions 8-10 that only have Exec method macro_rules! register_init_versions_8_to_10 { - ($registry:expr, $code_cid:expr, $($version:literal),+) => { - $( - paste! { - { - use fil_actor_init_state::[]::{ConstructorParams, ExecParams, Method}; + ($registry:expr, $code_cid:expr, $state_version:path) => {{ + use $state_version::{ConstructorParams, ExecParams, Method}; - register_actor_methods!( - $registry, - $code_cid, - [ - (Method::Constructor, ConstructorParams), - (Method::Exec, ExecParams), - ] - ); - } - } - )+ - }; + register_actor_methods!( + $registry, + $code_cid, + [ + (Method::Constructor, ConstructorParams), + (Method::Exec, ExecParams), + ] + ); + }}; } // Macro for versions 11-16 that have Exec4 macro_rules! register_init_versions_11_to_16 { - ($registry:expr, $code_cid:expr, $($version:literal),+) => { - $( - paste! { - { - use fil_actor_init_state::[]::{ConstructorParams, Exec4Params, ExecParams, Method}; + ($registry:expr, $code_cid:expr, $state_version:path) => {{ + use $state_version::{ConstructorParams, Exec4Params, ExecParams, Method}; - register_actor_methods!( - $registry, - $code_cid, - [ - (Method::Constructor, ConstructorParams), - (Method::Exec, ExecParams), - (Method::Exec4, Exec4Params) - ] - ); - } - } - )+ - }; + register_actor_methods!( + $registry, + $code_cid, + [ + (Method::Constructor, ConstructorParams), + (Method::Exec, ExecParams), + (Method::Exec4, Exec4Params) + ] + ); + }}; } -pub(crate) fn register_actor_methods(registry: &mut MethodRegistry, cid: Cid) { - register_init_versions_11_to_16!(registry, cid, 11, 12, 13, 14, 15, 16); - // Version 10 has Exec4, but it's not present in the `fil-actor-init-state` crate. - register_init_versions_8_to_10!(registry, cid, 8, 9, 10); +pub(crate) fn register_actor_methods(registry: &mut MethodRegistry, cid: Cid, version: u64) { + match version { + 8 => register_init_versions_8_to_10!(registry, cid, fil_actor_init_state::v8), + 9 => register_init_versions_8_to_10!(registry, cid, fil_actor_init_state::v9), + 10 => register_init_versions_8_to_10!(registry, cid, fil_actor_init_state::v10), + 11 => register_init_versions_11_to_16!(registry, cid, fil_actor_init_state::v11), + 12 => register_init_versions_11_to_16!(registry, cid, fil_actor_init_state::v12), + 13 => register_init_versions_11_to_16!(registry, cid, fil_actor_init_state::v13), + 14 => register_init_versions_11_to_16!(registry, cid, fil_actor_init_state::v14), + 15 => register_init_versions_11_to_16!(registry, cid, fil_actor_init_state::v15), + 16 => register_init_versions_11_to_16!(registry, cid, fil_actor_init_state::v16), + _ => {} + } } diff --git a/src/rpc/registry/actors/miner.rs b/src/rpc/registry/actors/miner.rs index 2e56371020aa..cc4f0a59624e 100644 --- a/src/rpc/registry/actors/miner.rs +++ b/src/rpc/registry/actors/miner.rs @@ -21,14 +21,17 @@ macro_rules! register_miner_version { }}; } -pub(crate) fn register_miner_actor_methods(registry: &mut MethodRegistry, cid: Cid) { - register_miner_version!(registry, cid, fil_actor_miner_state::v8); - register_miner_version!(registry, cid, fil_actor_miner_state::v9); - register_miner_version!(registry, cid, fil_actor_miner_state::v10); - register_miner_version!(registry, cid, fil_actor_miner_state::v11); - register_miner_version!(registry, cid, fil_actor_miner_state::v12); - register_miner_version!(registry, cid, fil_actor_miner_state::v13); - register_miner_version!(registry, cid, fil_actor_miner_state::v14); - register_miner_version!(registry, cid, fil_actor_miner_state::v15); - register_miner_version!(registry, cid, fil_actor_miner_state::v16); +pub(crate) fn register_miner_actor_methods(registry: &mut MethodRegistry, cid: Cid, version: u64) { + match version { + 8 => register_miner_version!(registry, cid, fil_actor_miner_state::v8), + 9 => register_miner_version!(registry, cid, fil_actor_miner_state::v9), + 10 => register_miner_version!(registry, cid, fil_actor_miner_state::v10), + 11 => register_miner_version!(registry, cid, fil_actor_miner_state::v11), + 12 => register_miner_version!(registry, cid, fil_actor_miner_state::v12), + 13 => register_miner_version!(registry, cid, fil_actor_miner_state::v13), + 14 => register_miner_version!(registry, cid, fil_actor_miner_state::v14), + 15 => register_miner_version!(registry, cid, fil_actor_miner_state::v15), + 16 => register_miner_version!(registry, cid, fil_actor_miner_state::v16), + _ => {} + } } diff --git a/src/rpc/registry/actors/mod.rs b/src/rpc/registry/actors/mod.rs index 4de42208df76..a76fa3eb299d 100644 --- a/src/rpc/registry/actors/mod.rs +++ b/src/rpc/registry/actors/mod.rs @@ -5,4 +5,5 @@ pub(crate) mod account; pub(crate) mod evm; pub(crate) mod init; pub(crate) mod miner; +pub(crate) mod power; pub(crate) mod system; diff --git a/src/rpc/registry/actors/power.rs b/src/rpc/registry/actors/power.rs new file mode 100644 index 000000000000..64a1224ac2b6 --- /dev/null +++ b/src/rpc/registry/actors/power.rs @@ -0,0 +1,130 @@ +// 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 for versions 8-9 that have limited methods +macro_rules! register_power_versions_8_to_9 { + ($registry:expr, $code_cid:expr, $state_version:path) => {{ + use $state_version::{ + CreateMinerParams, EnrollCronEventParams, Method, UpdateClaimedPowerParams, + }; + + // Register methods with parameters + register_actor_methods!( + $registry, + $code_cid, + [ + (Method::CreateMiner, CreateMinerParams), + (Method::UpdateClaimedPower, UpdateClaimedPowerParams), + (Method::EnrollCronEvent, EnrollCronEventParams), + ] + ); + + // Register methods without parameters + register_actor_methods!( + $registry, + $code_cid, + [ + (Method::Constructor, empty), + (Method::OnEpochTickEnd, empty), + (Method::CurrentTotalPower, empty), + ] + ); + }}; +} + +// Macro for versions 10-15 that have most methods but not MinerPowerParams +macro_rules! register_power_versions_10_to_15 { + ($registry:expr, $code_cid:expr, $state_version:path) => {{ + use $state_version::{ + CreateMinerParams, EnrollCronEventParams, Method, MinerRawPowerParams, + UpdateClaimedPowerParams, UpdatePledgeTotalParams, + }; + + // Register methods with parameters + register_actor_methods!( + $registry, + $code_cid, + [ + (Method::CreateMiner, CreateMinerParams), + (Method::UpdateClaimedPower, UpdateClaimedPowerParams), + (Method::EnrollCronEvent, EnrollCronEventParams), + (Method::UpdatePledgeTotal, UpdatePledgeTotalParams), + (Method::CreateMinerExported, CreateMinerParams), + (Method::MinerRawPowerExported, MinerRawPowerParams), + ] + ); + + // Register methods without parameters + register_actor_methods!( + $registry, + $code_cid, + [ + (Method::Constructor, empty), + (Method::OnEpochTickEnd, empty), + (Method::CurrentTotalPower, empty), + (Method::NetworkRawPowerExported, empty), + (Method::MinerCountExported, empty), + (Method::MinerConsensusCountExported, empty), + ] + ); + }}; +} + +// Macro for version 16 that has all methods +macro_rules! register_power_version_16 { + ($registry:expr, $code_cid:expr, $state_version:path) => {{ + use $state_version::{ + CreateMinerParams, EnrollCronEventParams, Method, MinerPowerParams, + MinerRawPowerParams, UpdateClaimedPowerParams, UpdatePledgeTotalParams, + }; + + // Register methods with parameters + register_actor_methods!( + $registry, + $code_cid, + [ + (Method::CreateMiner, CreateMinerParams), + (Method::UpdateClaimedPower, UpdateClaimedPowerParams), + (Method::EnrollCronEvent, EnrollCronEventParams), + (Method::UpdatePledgeTotal, UpdatePledgeTotalParams), + (Method::CreateMinerExported, CreateMinerParams), + (Method::MinerRawPowerExported, MinerRawPowerParams), + (Method::MinerPowerExported, MinerPowerParams), + ] + ); + + // Register methods without parameters + register_actor_methods!( + $registry, + $code_cid, + [ + (Method::Constructor, empty), + (Method::OnEpochTickEnd, empty), + (Method::CurrentTotalPower, empty), + (Method::NetworkRawPowerExported, empty), + (Method::MinerCountExported, empty), + (Method::MinerConsensusCountExported, empty), + ] + ); + }}; +} + +pub(crate) fn register_actor_methods(registry: &mut MethodRegistry, cid: Cid, version: u64) { + match version { + 8 => register_power_versions_8_to_9!(registry, cid, fil_actor_power_state::v8), + 9 => register_power_versions_8_to_9!(registry, cid, fil_actor_power_state::v9), + 10 => register_power_versions_10_to_15!(registry, cid, fil_actor_power_state::v10), + 11 => register_power_versions_10_to_15!(registry, cid, fil_actor_power_state::v11), + 12 => register_power_versions_10_to_15!(registry, cid, fil_actor_power_state::v12), + 13 => register_power_versions_10_to_15!(registry, cid, fil_actor_power_state::v13), + 14 => register_power_versions_10_to_15!(registry, cid, fil_actor_power_state::v14), + 15 => register_power_versions_10_to_15!(registry, cid, fil_actor_power_state::v15), + 16 => register_power_version_16!(registry, cid, fil_actor_power_state::v16), + _ => {} + } +} diff --git a/src/rpc/registry/actors/system.rs b/src/rpc/registry/actors/system.rs index 8781346ae88e..2cf78002c41f 100644 --- a/src/rpc/registry/actors/system.rs +++ b/src/rpc/registry/actors/system.rs @@ -19,14 +19,17 @@ macro_rules! register_system_version { }}; } -pub(crate) fn register_actor_methods(registry: &mut MethodRegistry, cid: Cid) { - register_system_version!(registry, cid, fil_actor_system_state::v8); - register_system_version!(registry, cid, fil_actor_system_state::v9); - register_system_version!(registry, cid, fil_actor_system_state::v10); - register_system_version!(registry, cid, fil_actor_system_state::v11); - register_system_version!(registry, cid, fil_actor_system_state::v12); - register_system_version!(registry, cid, fil_actor_system_state::v13); - register_system_version!(registry, cid, fil_actor_system_state::v14); - register_system_version!(registry, cid, fil_actor_system_state::v15); - register_system_version!(registry, cid, fil_actor_system_state::v16); +pub(crate) fn register_actor_methods(registry: &mut MethodRegistry, cid: Cid, version: u64) { + match version { + 8 => register_system_version!(registry, cid, fil_actor_system_state::v8), + 9 => register_system_version!(registry, cid, fil_actor_system_state::v9), + 10 => register_system_version!(registry, cid, fil_actor_system_state::v10), + 11 => register_system_version!(registry, cid, fil_actor_system_state::v11), + 12 => register_system_version!(registry, cid, fil_actor_system_state::v12), + 13 => register_system_version!(registry, cid, fil_actor_system_state::v13), + 14 => register_system_version!(registry, cid, fil_actor_system_state::v14), + 15 => register_system_version!(registry, cid, fil_actor_system_state::v15), + 16 => register_system_version!(registry, cid, fil_actor_system_state::v16), + _ => {} + } } diff --git a/src/rpc/registry/methods_reg.rs b/src/rpc/registry/methods_reg.rs index b4ecedfe1d02..eba6d300acb3 100644 --- a/src/rpc/registry/methods_reg.rs +++ b/src/rpc/registry/methods_reg.rs @@ -2,7 +2,6 @@ // SPDX-License-Identifier: Apache-2.0, MIT use crate::lotus_json::HasLotusJson; -use crate::rpc::registry::actors::system; use crate::rpc::registry::actors_reg::{ACTOR_REGISTRY, ActorRegistry}; use crate::shim::machine::BuiltinActor; use crate::shim::message::MethodNum; @@ -74,15 +73,18 @@ impl MethodRegistry { } fn register_known_methods(&mut self) { - use crate::rpc::registry::actors::{account, evm, init, miner}; + use crate::rpc::registry::actors::{account, evm, init, miner, power, system}; - for (&cid, &(actor_type, _version)) in ACTOR_REGISTRY.iter() { + for (&cid, &(actor_type, version)) in ACTOR_REGISTRY.iter() { match actor_type { - BuiltinActor::Account => account::register_account_actor_methods(self, cid), - BuiltinActor::Miner => miner::register_miner_actor_methods(self, cid), - BuiltinActor::EVM => evm::register_evm_actor_methods(self, cid), - BuiltinActor::Init => init::register_actor_methods(self, cid), - BuiltinActor::System => system::register_actor_methods(self, cid), + BuiltinActor::Account => { + account::register_account_actor_methods(self, cid, version) + } + BuiltinActor::Miner => miner::register_miner_actor_methods(self, cid, version), + BuiltinActor::EVM => evm::register_evm_actor_methods(self, cid, version), + BuiltinActor::Init => init::register_actor_methods(self, cid, version), + BuiltinActor::System => system::register_actor_methods(self, cid, version), + BuiltinActor::Power => power::register_actor_methods(self, cid, version), _ => {} } } @@ -98,7 +100,7 @@ pub fn deserialize_params( } macro_rules! register_actor_methods { - // Handle empty params case + // Handle an empty params case ($registry:expr, $code_cid:expr, [ $( ($method:expr, empty) ),* $(,)? ]) => { @@ -141,6 +143,7 @@ mod test { use serde::{Deserialize, Serialize}; use serde_json::json; + const V16: u64 = 16; // Test parameter type for testing #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] struct TestParams { @@ -169,13 +172,13 @@ mod test { Cid::new_v1(DAG_CBOR, MultihashCode::Blake2b256.digest(data)) } - fn get_real_actor_cid(target_actor: BuiltinActor) -> Option { + fn get_real_actor_cid(target_actor: BuiltinActor, target_version: u64) -> Option { ACTOR_REGISTRY .iter() - .find(|(_, (actor_type, _))| actor_type == &target_actor) - .map(|(&cid, _)| cid) + .find_map(|(&cid, &(actor_type, version))| { + (actor_type == target_actor && version == target_version).then_some(cid) + }) } - #[test] fn test_method_registry_initialization() { let result = deserialize_params(&create_test_cid(b"unknown"), 1, &[]); @@ -229,7 +232,7 @@ mod test { #[test] fn test_deserialize_params_registered_actor_unregistered_method() { - if let Some(account_cid) = get_real_actor_cid(BuiltinActor::Account) { + if let Some(account_cid) = get_real_actor_cid(BuiltinActor::Account, V16) { let unregistered_method = 999; let result = deserialize_params(&account_cid, unregistered_method, &[]); @@ -252,7 +255,7 @@ mod test { ]; for actor_type in supported_actors { - let actor_cid = get_real_actor_cid(actor_type).unwrap(); + let actor_cid = get_real_actor_cid(actor_type, V16).unwrap(); // Test that the Constructor method (typically method 1) is registered let constructor_method = 1; @@ -300,7 +303,7 @@ mod test { #[test] fn test_system_actor_deserialize_params_cbor_null() { - let system_cid = get_real_actor_cid(BuiltinActor::System) + let system_cid = get_real_actor_cid(BuiltinActor::System, V16) .expect("Should have System actor CID in registry"); // Test with null data diff --git a/src/tool/subcommands/api_cmd/api_compare_tests.rs b/src/tool/subcommands/api_cmd/api_compare_tests.rs index d469fa3afbee..287e53de9836 100644 --- a/src/tool/subcommands/api_cmd/api_compare_tests.rs +++ b/src/tool/subcommands/api_cmd/api_compare_tests.rs @@ -24,7 +24,7 @@ use crate::rpc::{Permission, prelude::*}; use crate::shim::actors::MarketActorStateLoad as _; use crate::shim::actors::market; use crate::shim::executor::Receipt; -use crate::shim::sector::SectorSize; +use crate::shim::sector::{SectorSize, StoragePower}; use crate::shim::{ address::{Address, Protocol}, crypto::Signature, @@ -1849,6 +1849,36 @@ fn state_decode_params_api_tests(tipset: &Tipset) -> anyhow::Result constructor_params: fvm_ipld_encoding::RawBytes::new(vec![0x12, 0x34, 0x56]), // dummy bytecode }; + let power_create_miner_params = fil_actor_power_state::v16::CreateMinerParams { + owner: Address::new_id(1000).into(), + worker: Address::new_id(1001).into(), + window_post_proof_type: fvm_shared4::sector::RegisteredPoStProof::StackedDRGWinning2KiBV1, + peer: b"miner".to_vec(), + multiaddrs: Default::default(), + }; + + // not supported by the lotus + // let _power_miner_power_exp_params = fil_actor_power_state::v16::MinerPowerParams{ + // miner: 1234, + // }; + + let power_update_claim_params = fil_actor_power_state::v16::UpdateClaimedPowerParams { + raw_byte_delta: StoragePower::from(1024u64), + quality_adjusted_delta: StoragePower::from(2048u64), + }; + + let power_enroll_event_params = fil_actor_power_state::v16::EnrollCronEventParams { + event_epoch: 123, + payload: Default::default(), + }; + + let power_update_pledge_ttl_params = fil_actor_power_state::v16::UpdatePledgeTotalParams { + pledge_delta: Default::default(), + }; + + let power_miner_raw_params = fil_actor_power_state::v16::MinerRawPowerParams { miner: 1234 }; + + use fil_actor_power_state::v16::Method; let tests = vec![ RpcTest::identity(StateDecodeParams::request(( MINER_ADDRESS, @@ -1898,6 +1928,50 @@ fn state_decode_params_api_tests(tipset: &Tipset) -> anyhow::Result to_vec(&init_exec4_params)?, tipset.key().into(), ))?), + RpcTest::identity(StateDecodeParams::request(( + Address::POWER_ACTOR, + Method::CreateMiner as u64, + to_vec(&power_create_miner_params)?, + tipset.key().into(), + ))?), + RpcTest::identity(StateDecodeParams::request(( + Address::POWER_ACTOR, + Method::UpdateClaimedPower as u64, + to_vec(&power_update_claim_params)?, + tipset.key().into(), + ))?), + RpcTest::identity(StateDecodeParams::request(( + Address::POWER_ACTOR, + Method::EnrollCronEvent as u64, + to_vec(&power_enroll_event_params)?, + tipset.key().into(), + ))?), + RpcTest::identity(StateDecodeParams::request(( + Address::POWER_ACTOR, + Method::UpdatePledgeTotal as u64, + to_vec(&power_update_pledge_ttl_params)?, + tipset.key().into(), + ))?), + RpcTest::identity(StateDecodeParams::request(( + Address::POWER_ACTOR, + Method::CreateMinerExported as u64, + to_vec(&power_create_miner_params)?, + tipset.key().into(), + ))?), + RpcTest::identity(StateDecodeParams::request(( + Address::POWER_ACTOR, + Method::MinerRawPowerExported as u64, + to_vec(&power_miner_raw_params)?, + tipset.key().into(), + ))?), + // Not supported by the lotus, + // TODO(go-state-types): https://github.com/filecoin-project/go-state-types/issues/401 + // RpcTest::identity(StateDecodeParams::request(( + // Address::POWER_ACTOR, + // Method::MinerPowerExported as u64, + // to_vec(&power_miner_power_exp_params)?, + // tipset.key().into(), + // ))?), ]; Ok(tests) diff --git a/src/tool/subcommands/api_cmd/test_snapshots.txt b/src/tool/subcommands/api_cmd/test_snapshots.txt index d5216a484c70..63fc67d0c68f 100644 --- a/src/tool/subcommands/api_cmd/test_snapshots.txt +++ b/src/tool/subcommands/api_cmd/test_snapshots.txt @@ -134,6 +134,12 @@ filecoin_statedecodeparams_1749826976836194.rpcsnap.json.zst filecoin_statedecodeparams_1749826976835026.rpcsnap.json.zst filecoin_statedecodeparams_1749826976835457.rpcsnap.json.zst filecoin_statedecodeparams_1750858921185411.rpcsnap.json.zst +filecoin_statedecodeparams_1753985928337767.rpcsnap.json.zst +filecoin_statedecodeparams_1753985928337915.rpcsnap.json.zst +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_statereplay_1743504051038215.rpcsnap.json.zst filecoin_statesearchmsg_1741784596636715.rpcsnap.json.zst filecoin_statesearchmsglimited_1741784596704876.rpcsnap.json.zst