forest-filecoin 0.33.2

// Copyright 2019-2026 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 crate::shim::{address::Address, sector::SectorNumber};
use cid::Cid;
use fil_actors_shared::actor_versions::ActorVersion;

macro_rules! register_miner_basic_methods {
    ($registry:expr, $code_cid:expr, $state_version:path) => {{
        use $state_version::{
            ApplyRewardParams, ChangeMultiaddrsParams, ChangePeerIDParams,
            ChangeWorkerAddressParams, CheckSectorProvenParams, CompactPartitionsParams,
            CompactSectorNumbersParams, DeclareFaultsParams, DeclareFaultsRecoveredParams,
            DeferredCronEventParams, DisputeWindowedPoStParams, Method, MinerConstructorParams,
            ReportConsensusFaultParams, SubmitWindowedPoStParams, TerminateSectorsParams,
            WithdrawBalanceParams,
        };

        register_actor_methods!(
            $registry,
            $code_cid,
            [
                (Method::Constructor, MinerConstructorParams),
                (Method::ChangeWorkerAddress, ChangeWorkerAddressParams),
                (Method::ChangePeerID, ChangePeerIDParams),
                (Method::SubmitWindowedPoSt, SubmitWindowedPoStParams),
                (Method::TerminateSectors, TerminateSectorsParams),
                (Method::DeclareFaults, DeclareFaultsParams),
                (Method::DeclareFaultsRecovered, DeclareFaultsRecoveredParams),
                (Method::OnDeferredCronEvent, DeferredCronEventParams),
                (Method::CheckSectorProven, CheckSectorProvenParams),
                (Method::ApplyRewards, ApplyRewardParams),
                (Method::ReportConsensusFault, ReportConsensusFaultParams),
                (Method::WithdrawBalance, WithdrawBalanceParams),
                (Method::ChangeMultiaddrs, ChangeMultiaddrsParams),
                (Method::CompactPartitions, CompactPartitionsParams),
                (Method::CompactSectorNumbers, CompactSectorNumbersParams),
                (Method::DisputeWindowedPoSt, DisputeWindowedPoStParams),
            ]
        );

        // Register methods without parameters
        register_actor_methods!(
            $registry,
            $code_cid,
            [
                (Method::ControlAddresses, empty),
                (Method::RepayDebt, empty),
            ]
        );
    }};
}

macro_rules! register_miner_common_methods_v10_onwards {
    ($registry:expr, $code_cid:expr, $state_version:path) => {{
        register_miner_basic_methods!($registry, $code_cid, $state_version);

        use $state_version::{
            ChangeBeneficiaryParams, ChangeMultiaddrsParams, ChangePeerIDParams,
            ChangeWorkerAddressParams, ExtendSectorExpiration2Params, IsControllingAddressParam,
            Method, PreCommitSectorBatchParams2, WithdrawBalanceParams,
        };

        // Register methods with parameters
        register_actor_methods!(
            $registry,
            $code_cid,
            [
                (Method::PreCommitSectorBatch2, PreCommitSectorBatchParams2),
                (Method::ChangeBeneficiary, ChangeBeneficiaryParams),
                (
                    Method::ExtendSectorExpiration2,
                    ExtendSectorExpiration2Params
                ),
                (Method::ChangePeerIDExported, ChangePeerIDParams),
                (Method::WithdrawBalanceExported, WithdrawBalanceParams),
                (Method::ChangeMultiaddrsExported, ChangeMultiaddrsParams),
                (Method::ChangeBeneficiaryExported, ChangeBeneficiaryParams),
                (
                    Method::IsControllingAddressExported,
                    IsControllingAddressParam
                ),
                (
                    Method::ChangeWorkerAddressExported,
                    ChangeWorkerAddressParams
                ),
            ]
        );

        register_actor_methods!(
            $registry,
            $code_cid,
            [
                (Method::GetBeneficiary, empty),
                (Method::ConfirmChangeWorkerAddress, empty),
                (Method::ConfirmChangeWorkerAddressExported, empty),
                (Method::RepayDebtExported, empty),
                (Method::GetBeneficiaryExported, empty),
                (Method::GetOwnerExported, empty),
                (Method::GetSectorSizeExported, empty),
                (Method::GetAvailableBalanceExported, empty),
                (Method::GetVestingFundsExported, empty),
                (Method::GetPeerIDExported, empty),
                (Method::GetMultiaddrsExported, empty),
            ]
        );
    }};
}

macro_rules! register_miner_common_method_v14_onwards {
    ($registry:expr, $code_cid:expr, $state_version:path) => {{
        use $state_version::{
            ChangeOwnerAddressParams, InternalSectorSetupForPresealParams, Method,
            ProveCommitSectors3Params, ProveCommitSectorsNIParams, ProveReplicaUpdates3Params,
        };
        register_actor_methods!(
            $registry,
            $code_cid,
            [
                (Method::ProveCommitSectors3, ProveCommitSectors3Params),
                (Method::ProveReplicaUpdates3, ProveReplicaUpdates3Params),
                (Method::ProveCommitSectorsNI, ProveCommitSectorsNIParams),
                (Method::ChangeOwnerAddress, ChangeOwnerAddressParams),
                (Method::ChangeOwnerAddressExported, ChangeOwnerAddressParams),
                (
                    Method::InternalSectorSetupForPreseal,
                    InternalSectorSetupForPresealParams
                ),
            ]
        );
    }};
}

macro_rules! register_miner_common_method_v16_onwards {
    ($registry:expr, $code_cid:expr, $state_version:path) => {{
        use $state_version::{MaxTerminationFeeParams, Method};
        register_actor_methods!(
            $registry,
            $code_cid,
            [(Method::MaxTerminationFeeExported, MaxTerminationFeeParams),]
        );

        register_actor_methods!(
            $registry,
            $code_cid,
            [(Method::InitialPledgeExported, empty)]
        );
    }};
}

macro_rules! register_miner_common_method_v18_onwards {
    ($registry:expr, $code_cid:expr, $state_version:path) => {{
        use $state_version::{GenerateSectorLocationParams, Method, ValidateSectorStatusParams};
        register_actor_methods!(
            $registry,
            $code_cid,
            [
                (
                    Method::GenerateSectorLocationExported,
                    GenerateSectorLocationParams
                ),
                (
                    Method::ValidateSectorStatusExported,
                    ValidateSectorStatusParams
                ),
                (Method::GetNominalSectorExpirationExported, SectorNumber),
            ]
        );
    }};
}

fn register_miner_version_8(registry: &mut MethodRegistry, cid: Cid) {
    register_miner_basic_methods!(registry, cid, fil_actor_miner_state::v8);

    use fil_actor_miner_state::v8::{
        ConfirmSectorProofsParams, ExtendSectorExpirationParams, Method,
        PreCommitSectorBatchParams, PreCommitSectorParams, ProveCommitAggregateParams,
        ProveCommitSectorParams, ProveReplicaUpdatesParams,
    };

    register_actor_methods!(
        registry,
        cid,
        [
            (Method::ChangeOwnerAddress, Address),
            (Method::PreCommitSector, PreCommitSectorParams),
            (Method::ProveCommitSector, ProveCommitSectorParams),
            (Method::ExtendSectorExpiration, ExtendSectorExpirationParams),
            (Method::PreCommitSectorBatch, PreCommitSectorBatchParams),
            (Method::ConfirmSectorProofsValid, ConfirmSectorProofsParams),
            (Method::ProveCommitAggregate, ProveCommitAggregateParams),
            (Method::ProveReplicaUpdates, ProveReplicaUpdatesParams),
        ]
    );

    register_actor_methods!(registry, cid, [(Method::ConfirmUpdateWorkerKey, empty)]);
}

fn register_miner_version_9(registry: &mut MethodRegistry, cid: Cid) {
    register_miner_basic_methods!(registry, cid, fil_actor_miner_state::v9);

    use fil_actor_miner_state::v9::{
        ChangeBeneficiaryParams, ConfirmSectorProofsParams, ExtendSectorExpiration2Params,
        ExtendSectorExpirationParams, Method, PreCommitSectorBatchParams,
        PreCommitSectorBatchParams2, PreCommitSectorParams, ProveCommitAggregateParams,
        ProveCommitSectorParams, ProveReplicaUpdatesParams, ProveReplicaUpdatesParams2,
    };

    register_actor_methods!(
        registry,
        cid,
        [
            (Method::PreCommitSector, PreCommitSectorParams),
            (Method::ProveCommitSector, ProveCommitSectorParams),
            (Method::ExtendSectorExpiration, ExtendSectorExpirationParams),
            (Method::PreCommitSectorBatch, PreCommitSectorBatchParams),
            (Method::PreCommitSectorBatch2, PreCommitSectorBatchParams2),
            (Method::ChangeOwnerAddress, Address),
            (Method::ProveReplicaUpdates2, ProveReplicaUpdatesParams2),
            (Method::ChangeBeneficiary, ChangeBeneficiaryParams),
            (
                Method::ExtendSectorExpiration2,
                ExtendSectorExpiration2Params
            ),
            (Method::ConfirmSectorProofsValid, ConfirmSectorProofsParams),
            (Method::ProveCommitAggregate, ProveCommitAggregateParams),
            (Method::ProveReplicaUpdates, ProveReplicaUpdatesParams),
        ]
    );

    register_actor_methods!(
        registry,
        cid,
        [
            (Method::GetBeneficiary, empty),
            (Method::ConfirmUpdateWorkerKey, empty)
        ]
    );
}

fn register_miner_version_10(registry: &mut MethodRegistry, cid: Cid) {
    register_miner_common_methods_v10_onwards!(registry, cid, fil_actor_miner_state::v10);

    use fil_actor_miner_state::v10::{
        ConfirmSectorProofsParams, ExtendSectorExpiration2Params, ExtendSectorExpirationParams,
        Method, PreCommitSectorBatchParams, PreCommitSectorParams, ProveCommitAggregateParams,
        ProveCommitSectorParams, ProveReplicaUpdatesParams, ProveReplicaUpdatesParams2,
    };

    register_actor_methods!(
        registry,
        cid,
        [
            (Method::PreCommitSector, PreCommitSectorParams),
            (Method::ExtendSectorExpiration, ExtendSectorExpirationParams),
            (Method::ProveReplicaUpdates2, ProveReplicaUpdatesParams2),
            (Method::ProveCommitSector, ProveCommitSectorParams),
            (Method::PreCommitSectorBatch, PreCommitSectorBatchParams),
            (
                Method::ExtendSectorExpiration2,
                ExtendSectorExpiration2Params
            ),
            (Method::ChangeOwnerAddress, Address),
            (Method::ChangeOwnerAddressExported, Address),
            (Method::ConfirmSectorProofsValid, ConfirmSectorProofsParams),
            (Method::ProveCommitAggregate, ProveCommitAggregateParams),
            (Method::ProveReplicaUpdates, ProveReplicaUpdatesParams),
        ]
    );
}

fn register_miner_version_11(registry: &mut MethodRegistry, cid: Cid) {
    register_miner_common_methods_v10_onwards!(registry, cid, fil_actor_miner_state::v11);

    use fil_actor_miner_state::v11::{
        ChangeOwnerAddressParams, ConfirmSectorProofsParams, ExtendSectorExpiration2Params,
        ExtendSectorExpirationParams, Method, PreCommitSectorBatchParams, PreCommitSectorParams,
        ProveCommitAggregateParams, ProveCommitSectorParams, ProveReplicaUpdatesParams,
        ProveReplicaUpdatesParams2,
    };

    register_actor_methods!(
        registry,
        cid,
        [
            (Method::PreCommitSector, PreCommitSectorParams),
            (Method::ExtendSectorExpiration, ExtendSectorExpirationParams),
            (Method::ProveReplicaUpdates2, ProveReplicaUpdatesParams2),
            (Method::ProveCommitSector, ProveCommitSectorParams),
            (Method::PreCommitSectorBatch, PreCommitSectorBatchParams),
            (
                Method::ExtendSectorExpiration2,
                ExtendSectorExpiration2Params
            ),
            (Method::ChangeOwnerAddress, ChangeOwnerAddressParams),
            (Method::ChangeOwnerAddressExported, ChangeOwnerAddressParams),
            (Method::ConfirmSectorProofsValid, ConfirmSectorProofsParams),
            (Method::ProveCommitAggregate, ProveCommitAggregateParams),
            (Method::ProveReplicaUpdates, ProveReplicaUpdatesParams),
        ]
    );
}

fn register_miner_version_12(registry: &mut MethodRegistry, cid: Cid) {
    register_miner_common_methods_v10_onwards!(registry, cid, fil_actor_miner_state::v12);

    use fil_actor_miner_state::v12::{
        ChangeOwnerAddressParams, ConfirmSectorProofsParams, ExtendSectorExpirationParams, Method,
        PreCommitSectorBatchParams, PreCommitSectorParams, ProveCommitAggregateParams,
        ProveCommitSectorParams, ProveReplicaUpdatesParams, ProveReplicaUpdatesParams2,
    };
    register_actor_methods!(
        registry,
        cid,
        [
            (Method::PreCommitSector, PreCommitSectorParams),
            (Method::ProveReplicaUpdates2, ProveReplicaUpdatesParams2),
            (Method::ProveCommitSector, ProveCommitSectorParams),
            (Method::ExtendSectorExpiration, ExtendSectorExpirationParams),
            (Method::PreCommitSectorBatch, PreCommitSectorBatchParams),
            (Method::ChangeOwnerAddress, ChangeOwnerAddressParams),
            (Method::ChangeOwnerAddressExported, ChangeOwnerAddressParams),
            (Method::ConfirmSectorProofsValid, ConfirmSectorProofsParams),
            (Method::ProveCommitAggregate, ProveCommitAggregateParams),
            (Method::ProveReplicaUpdates, ProveReplicaUpdatesParams),
        ]
    );
}

fn register_miner_version_13(registry: &mut MethodRegistry, cid: Cid) {
    register_miner_common_methods_v10_onwards!(registry, cid, fil_actor_miner_state::v13);

    use fil_actor_miner_state::v13::{
        ChangeOwnerAddressParams, ConfirmSectorProofsParams, ExtendSectorExpirationParams, Method,
        ProveCommitAggregateParams, ProveCommitSectorParams, ProveCommitSectors3Params,
        ProveReplicaUpdatesParams,
    };
    register_actor_methods!(
        registry,
        cid,
        [
            (Method::ProveCommitSector, ProveCommitSectorParams),
            (Method::ExtendSectorExpiration, ExtendSectorExpirationParams),
            (Method::ProveCommitSectors3, ProveCommitSectors3Params),
            (Method::ChangeOwnerAddress, ChangeOwnerAddressParams),
            (Method::ChangeOwnerAddressExported, ChangeOwnerAddressParams),
            (Method::ConfirmSectorProofsValid, ConfirmSectorProofsParams),
            (Method::ProveCommitAggregate, ProveCommitAggregateParams),
            (Method::ProveReplicaUpdates, ProveReplicaUpdatesParams),
        ]
    );
}

fn register_miner_versions_14(registry: &mut MethodRegistry, cid: Cid) {
    register_miner_common_methods_v10_onwards!(registry, cid, fil_actor_miner_state::v14);
    register_miner_common_method_v14_onwards!(registry, cid, fil_actor_miner_state::v14);
    use fil_actor_miner_state::v14::{
        ExtendSectorExpirationParams, Method, ProveCommitAggregateParams, ProveReplicaUpdatesParams,
    };
    register_actor_methods!(
        registry,
        cid,
        [
            (Method::ExtendSectorExpiration, ExtendSectorExpirationParams),
            (Method::ProveCommitAggregate, ProveCommitAggregateParams),
            (Method::ProveReplicaUpdates, ProveReplicaUpdatesParams),
        ]
    );
}

fn register_miner_version_15(registry: &mut MethodRegistry, cid: Cid) {
    register_miner_common_methods_v10_onwards!(registry, cid, fil_actor_miner_state::v15);
    register_miner_common_method_v14_onwards!(registry, cid, fil_actor_miner_state::v15);
    use fil_actor_miner_state::v15::{
        ExtendSectorExpirationParams, Method, ProveCommitAggregateParams, ProveReplicaUpdatesParams,
    };
    register_actor_methods!(
        registry,
        cid,
        [
            (Method::ExtendSectorExpiration, ExtendSectorExpirationParams),
            (Method::ProveCommitAggregate, ProveCommitAggregateParams),
            (Method::ProveReplicaUpdates, ProveReplicaUpdatesParams),
        ]
    );
}

fn register_miner_version_16(registry: &mut MethodRegistry, cid: Cid) {
    register_miner_common_methods_v10_onwards!(registry, cid, fil_actor_miner_state::v16);
    register_miner_common_method_v14_onwards!(registry, cid, fil_actor_miner_state::v16);
    register_miner_common_method_v16_onwards!(registry, cid, fil_actor_miner_state::v16);

    use fil_actor_miner_state::v16::{
        ExtendSectorExpirationParams, Method, ProveCommitAggregateParams, ProveReplicaUpdatesParams,
    };
    register_actor_methods!(
        registry,
        cid,
        [
            (Method::ExtendSectorExpiration, ExtendSectorExpirationParams),
            (Method::ProveCommitAggregate, ProveCommitAggregateParams),
            (Method::ProveReplicaUpdates, ProveReplicaUpdatesParams),
        ]
    );
}

fn register_miner_version_17(registry: &mut MethodRegistry, cid: Cid) {
    register_miner_common_methods_v10_onwards!(registry, cid, fil_actor_miner_state::v17);
    register_miner_common_method_v14_onwards!(registry, cid, fil_actor_miner_state::v17);
    register_miner_common_method_v16_onwards!(registry, cid, fil_actor_miner_state::v17);
}

fn register_miner_version_18(registry: &mut MethodRegistry, cid: Cid) {
    register_miner_common_methods_v10_onwards!(registry, cid, fil_actor_miner_state::v18);
    register_miner_common_method_v14_onwards!(registry, cid, fil_actor_miner_state::v18);
    register_miner_common_method_v16_onwards!(registry, cid, fil_actor_miner_state::v18);
    register_miner_common_method_v18_onwards!(registry, cid, fil_actor_miner_state::v18);
}

pub(crate) fn register_miner_actor_methods(
    registry: &mut MethodRegistry,
    cid: Cid,
    version: ActorVersion,
) {
    match version {
        ActorVersion::V8 => register_miner_version_8(registry, cid),
        ActorVersion::V9 => register_miner_version_9(registry, cid),
        ActorVersion::V10 => register_miner_version_10(registry, cid),
        ActorVersion::V11 => register_miner_version_11(registry, cid),
        ActorVersion::V12 => register_miner_version_12(registry, cid),
        ActorVersion::V13 => register_miner_version_13(registry, cid),
        ActorVersion::V14 => register_miner_versions_14(registry, cid),
        ActorVersion::V15 => register_miner_version_15(registry, cid),
        ActorVersion::V16 => register_miner_version_16(registry, cid),
        ActorVersion::V17 => register_miner_version_17(registry, cid),
        ActorVersion::V18 => register_miner_version_18(registry, cid),
    }
}