action_kind.rs

// DO NOT EDIT. GENERATED BY `node/build.rs`
//
// This file includes the [ActionKindGet] trait implementation for all action variants.
// It also defines the [ActionKind] enum that consolidates all action types.
//
// Why? As a substitute of the derive macro provided by the [enum-kinds](https://crates.io/crates/enum-kinds).
//
// This arrangement helps eliminate macro overhead while also enabling us to aggregate multiple action types
// into an single [ActionKind] enum.
// That enables uncoupling through the partitioning of actions into multiple types that get combined by a
// top-level [Action] type in a way that helps the compiler avoid the recompilation of all the actions
// related code for every single change.

use num_enum::TryFromPrimitive;
use serde::{Deserialize, Serialize};

use crate::block_producer::vrf_evaluator::BlockProducerVrfEvaluatorAction;
use crate::block_producer::BlockProducerAction;
use crate::consensus::ConsensusAction;
use crate::event_source::EventSourceAction;
use crate::external_snark_worker::ExternalSnarkWorkerAction;
use crate::p2p::channels::best_tip::P2pChannelsBestTipAction;
use crate::p2p::channels::rpc::P2pChannelsRpcAction;
use crate::p2p::channels::snark::P2pChannelsSnarkAction;
use crate::p2p::channels::snark_job_commitment::P2pChannelsSnarkJobCommitmentAction;
use crate::p2p::channels::{P2pChannelsAction, P2pChannelsMessageReceivedAction};
use crate::p2p::connection::incoming::P2pConnectionIncomingAction;
use crate::p2p::connection::outgoing::P2pConnectionOutgoingAction;
use crate::p2p::connection::P2pConnectionAction;
use crate::p2p::disconnection::P2pDisconnectionAction;
use crate::p2p::discovery::P2pDiscoveryAction;
use crate::p2p::listen::P2pListenAction;
use crate::p2p::network::kad::bootstrap::P2pNetworkKadBootstrapAction;
use crate::p2p::network::kad::request::P2pNetworkKadRequestAction;
use crate::p2p::network::kad::stream::P2pNetworkKademliaStreamAction;
use crate::p2p::network::kad::{P2pNetworkKadAction, P2pNetworkKademliaAction};
use crate::p2p::network::noise::P2pNetworkNoiseAction;
use crate::p2p::network::pnet::P2pNetworkPnetAction;
use crate::p2p::network::rpc::P2pNetworkRpcAction;
use crate::p2p::network::scheduler::P2pNetworkSchedulerAction;
use crate::p2p::network::select::P2pNetworkSelectAction;
use crate::p2p::network::yamux::P2pNetworkYamuxAction;
use crate::p2p::network::P2pNetworkAction;
use crate::p2p::peer::P2pPeerAction;
use crate::p2p::P2pAction;
use crate::rpc::RpcAction;
use crate::snark::block_verify::SnarkBlockVerifyAction;
use crate::snark::user_command_verify::SnarkUserCommandVerifyAction;
use crate::snark::work_verify::SnarkWorkVerifyAction;
use crate::snark::SnarkAction;
use crate::snark_pool::candidate::SnarkPoolCandidateAction;
use crate::snark_pool::SnarkPoolAction;
use crate::transaction_pool::TransactionPoolAction;
use crate::transition_frontier::genesis::TransitionFrontierGenesisAction;
use crate::transition_frontier::sync::ledger::snarked::TransitionFrontierSyncLedgerSnarkedAction;
use crate::transition_frontier::sync::ledger::staged::TransitionFrontierSyncLedgerStagedAction;
use crate::transition_frontier::sync::ledger::TransitionFrontierSyncLedgerAction;
use crate::transition_frontier::sync::TransitionFrontierSyncAction;
use crate::transition_frontier::TransitionFrontierAction;
use crate::watched_accounts::WatchedAccountsAction;
use crate::{Action, ActionKindGet, CheckTimeoutsAction};

/// Unified kind enum for all action types
#[derive(
    Serialize, Deserialize, TryFromPrimitive, Debug, Ord, PartialOrd, Eq, PartialEq, Clone, Copy,
)]
#[repr(u16)]
pub enum ActionKind {
    None,
    BlockProducerBestTipUpdate,
    BlockProducerBlockInject,
    BlockProducerBlockInjected,
    BlockProducerBlockProduced,
    BlockProducerBlockProveInit,
    BlockProducerBlockProvePending,
    BlockProducerBlockProveSuccess,
    BlockProducerBlockUnprovenBuild,
    BlockProducerStagedLedgerDiffCreateInit,
    BlockProducerStagedLedgerDiffCreatePending,
    BlockProducerStagedLedgerDiffCreateSuccess,
    BlockProducerWonSlot,
    BlockProducerWonSlotDiscard,
    BlockProducerWonSlotProduceInit,
    BlockProducerWonSlotSearch,
    BlockProducerWonSlotWait,
    BlockProducerVrfEvaluatorBeginDelegatorTableConstruction,
    BlockProducerVrfEvaluatorBeginEpochEvaluation,
    BlockProducerVrfEvaluatorCheckEpochBounds,
    BlockProducerVrfEvaluatorCheckEpochEvaluability,
    BlockProducerVrfEvaluatorCleanupOldSlots,
    BlockProducerVrfEvaluatorContinueEpochEvaluation,
    BlockProducerVrfEvaluatorEvaluateSlot,
    BlockProducerVrfEvaluatorFinalizeDelegatorTableConstruction,
    BlockProducerVrfEvaluatorFinalizeEvaluatorInitialization,
    BlockProducerVrfEvaluatorFinishEpochEvaluation,
    BlockProducerVrfEvaluatorInitializeEpochEvaluation,
    BlockProducerVrfEvaluatorInitializeEvaluator,
    BlockProducerVrfEvaluatorProcessSlotEvaluationSuccess,
    BlockProducerVrfEvaluatorRecordLastBlockHeightInEpoch,
    BlockProducerVrfEvaluatorSelectInitialSlot,
    BlockProducerVrfEvaluatorWaitForNextEvaluation,
    CheckTimeouts,
    ConsensusBestTipUpdate,
    ConsensusBlockChainProofUpdate,
    ConsensusBlockReceived,
    ConsensusBlockSnarkVerifyPending,
    ConsensusBlockSnarkVerifySuccess,
    ConsensusDetectForkRange,
    ConsensusLongRangeForkResolve,
    ConsensusPrune,
    ConsensusShortRangeForkResolve,
    EventSourceNewEvent,
    EventSourceProcessEvents,
    EventSourceWaitForEvents,
    EventSourceWaitTimeout,
    ExternalSnarkWorkerCancelWork,
    ExternalSnarkWorkerError,
    ExternalSnarkWorkerKill,
    ExternalSnarkWorkerKilled,
    ExternalSnarkWorkerPruneWork,
    ExternalSnarkWorkerStart,
    ExternalSnarkWorkerStartTimeout,
    ExternalSnarkWorkerStarted,
    ExternalSnarkWorkerSubmitWork,
    ExternalSnarkWorkerWorkCancelled,
    ExternalSnarkWorkerWorkError,
    ExternalSnarkWorkerWorkResult,
    ExternalSnarkWorkerWorkTimeout,
    P2pChannelsBestTipInit,
    P2pChannelsBestTipPending,
    P2pChannelsBestTipReady,
    P2pChannelsBestTipReceived,
    P2pChannelsBestTipRequestReceived,
    P2pChannelsBestTipRequestSend,
    P2pChannelsBestTipResponseSend,
    P2pChannelsMessageReceived,
    P2pChannelsRpcInit,
    P2pChannelsRpcPending,
    P2pChannelsRpcReady,
    P2pChannelsRpcRequestReceived,
    P2pChannelsRpcRequestSend,
    P2pChannelsRpcResponseReceived,
    P2pChannelsRpcResponseSend,
    P2pChannelsRpcTimeout,
    P2pChannelsSnarkInit,
    P2pChannelsSnarkLibp2pBroadcast,
    P2pChannelsSnarkLibp2pReceived,
    P2pChannelsSnarkPending,
    P2pChannelsSnarkPromiseReceived,
    P2pChannelsSnarkReady,
    P2pChannelsSnarkReceived,
    P2pChannelsSnarkRequestReceived,
    P2pChannelsSnarkRequestSend,
    P2pChannelsSnarkResponseSend,
    P2pChannelsSnarkJobCommitmentInit,
    P2pChannelsSnarkJobCommitmentPending,
    P2pChannelsSnarkJobCommitmentPromiseReceived,
    P2pChannelsSnarkJobCommitmentReady,
    P2pChannelsSnarkJobCommitmentReceived,
    P2pChannelsSnarkJobCommitmentRequestReceived,
    P2pChannelsSnarkJobCommitmentRequestSend,
    P2pChannelsSnarkJobCommitmentResponseSend,
    P2pConnectionIncomingAnswerReady,
    P2pConnectionIncomingAnswerSdpCreateError,
    P2pConnectionIncomingAnswerSdpCreatePending,
    P2pConnectionIncomingAnswerSdpCreateSuccess,
    P2pConnectionIncomingAnswerSendSuccess,
    P2pConnectionIncomingError,
    P2pConnectionIncomingFinalizeError,
    P2pConnectionIncomingFinalizePending,
    P2pConnectionIncomingFinalizeSuccess,
    P2pConnectionIncomingInit,
    P2pConnectionIncomingLibp2pReceived,
    P2pConnectionIncomingSuccess,
    P2pConnectionIncomingTimeout,
    P2pConnectionOutgoingAnswerRecvError,
    P2pConnectionOutgoingAnswerRecvPending,
    P2pConnectionOutgoingAnswerRecvSuccess,
    P2pConnectionOutgoingError,
    P2pConnectionOutgoingFinalizeError,
    P2pConnectionOutgoingFinalizePending,
    P2pConnectionOutgoingFinalizeSuccess,
    P2pConnectionOutgoingInit,
    P2pConnectionOutgoingOfferReady,
    P2pConnectionOutgoingOfferSdpCreateError,
    P2pConnectionOutgoingOfferSdpCreatePending,
    P2pConnectionOutgoingOfferSdpCreateSuccess,
    P2pConnectionOutgoingOfferSendSuccess,
    P2pConnectionOutgoingRandomInit,
    P2pConnectionOutgoingReconnect,
    P2pConnectionOutgoingSuccess,
    P2pConnectionOutgoingTimeout,
    P2pDisconnectionFinish,
    P2pDisconnectionInit,
    P2pDiscoveryInit,
    P2pDiscoveryKademliaAddRoute,
    P2pDiscoveryKademliaBootstrap,
    P2pDiscoveryKademliaFailure,
    P2pDiscoveryKademliaInit,
    P2pDiscoveryKademliaSuccess,
    P2pDiscoverySuccess,
    P2pListenClosed,
    P2pListenError,
    P2pListenExpired,
    P2pListenNew,
    P2pNetworkKadBootstrapCreateRequests,
    P2pNetworkKadBootstrapRequestDone,
    P2pNetworkKadBootstrapRequestError,
    P2pNetworkKadRequestError,
    P2pNetworkKadRequestMuxReady,
    P2pNetworkKadRequestNew,
    P2pNetworkKadRequestPeerIsConnecting,
    P2pNetworkKadRequestPrune,
    P2pNetworkKadRequestReplyReceived,
    P2pNetworkKadRequestRequestSent,
    P2pNetworkKadRequestStreamIsCreating,
    P2pNetworkKadRequestStreamReady,
    P2pNetworkKademliaAnswerFindNodeRequest,
    P2pNetworkKademliaBootstrapFinished,
    P2pNetworkKademliaStartBootstrap,
    P2pNetworkKademliaUpdateFindNodeRequest,
    P2pNetworkKademliaStreamClose,
    P2pNetworkKademliaStreamIncomingData,
    P2pNetworkKademliaStreamNew,
    P2pNetworkKademliaStreamOutgoingDataReady,
    P2pNetworkKademliaStreamPrune,
    P2pNetworkKademliaStreamRemoteClose,
    P2pNetworkKademliaStreamSendRequest,
    P2pNetworkKademliaStreamSendResponse,
    P2pNetworkKademliaStreamWaitIncoming,
    P2pNetworkKademliaStreamWaitOutgoing,
    P2pNetworkNoiseDecryptedData,
    P2pNetworkNoiseHandshakeDone,
    P2pNetworkNoiseIncomingChunk,
    P2pNetworkNoiseIncomingData,
    P2pNetworkNoiseInit,
    P2pNetworkNoiseOutgoingChunk,
    P2pNetworkNoiseOutgoingData,
    P2pNetworkPnetIncomingData,
    P2pNetworkPnetOutgoingData,
    P2pNetworkPnetSetupNonce,
    P2pNetworkRpcIncomingData,
    P2pNetworkRpcIncomingMessage,
    P2pNetworkRpcInit,
    P2pNetworkRpcOutgoingData,
    P2pNetworkRpcOutgoingQuery,
    P2pNetworkRpcOutgoingResponse,
    P2pNetworkRpcPrunePending,
    P2pNetworkSchedulerDisconnect,
    P2pNetworkSchedulerDisconnected,
    P2pNetworkSchedulerError,
    P2pNetworkSchedulerIncomingConnectionIsReady,
    P2pNetworkSchedulerIncomingDataDidReceive,
    P2pNetworkSchedulerIncomingDataIsReady,
    P2pNetworkSchedulerIncomingDidAccept,
    P2pNetworkSchedulerInterfaceDetected,
    P2pNetworkSchedulerInterfaceExpired,
    P2pNetworkSchedulerOutgoingDidConnect,
    P2pNetworkSchedulerSelectDone,
    P2pNetworkSchedulerSelectError,
    P2pNetworkSchedulerYamuxDidInit,
    P2pNetworkSelectIncomingData,
    P2pNetworkSelectIncomingToken,
    P2pNetworkSelectInit,
    P2pNetworkSelectOutgoingTokens,
    P2pNetworkYamuxIncomingData,
    P2pNetworkYamuxIncomingFrame,
    P2pNetworkYamuxOpenStream,
    P2pNetworkYamuxOutgoingData,
    P2pNetworkYamuxOutgoingFrame,
    P2pNetworkYamuxPingStream,
    P2pPeerBestTipUpdate,
    P2pPeerReady,
    RpcActionStatsGet,
    RpcDiscoveryBoostrapStats,
    RpcDiscoveryRoutingTable,
    RpcFinish,
    RpcGlobalStateGet,
    RpcHealthCheck,
    RpcMessageProgressGet,
    RpcP2pConnectionIncomingError,
    RpcP2pConnectionIncomingInit,
    RpcP2pConnectionIncomingPending,
    RpcP2pConnectionIncomingRespond,
    RpcP2pConnectionIncomingSuccess,
    RpcP2pConnectionOutgoingError,
    RpcP2pConnectionOutgoingInit,
    RpcP2pConnectionOutgoingPending,
    RpcP2pConnectionOutgoingSuccess,
    RpcPeersGet,
    RpcReadinessCheck,
    RpcScanStateSummaryGet,
    RpcSnarkPoolAvailableJobsGet,
    RpcSnarkPoolJobGet,
    RpcSnarkerConfigGet,
    RpcSnarkerJobCommit,
    RpcSnarkerJobSpec,
    RpcSnarkerWorkersGet,
    RpcSyncStatsGet,
    SnarkBlockVerifyError,
    SnarkBlockVerifyFinish,
    SnarkBlockVerifyInit,
    SnarkBlockVerifyPending,
    SnarkBlockVerifySuccess,
    SnarkPoolAutoCreateCommitment,
    SnarkPoolCheckTimeouts,
    SnarkPoolCommitmentAdd,
    SnarkPoolCommitmentCreate,
    SnarkPoolJobCommitmentTimeout,
    SnarkPoolJobsUpdate,
    SnarkPoolP2pSend,
    SnarkPoolP2pSendAll,
    SnarkPoolWorkAdd,
    SnarkPoolCandidateInfoReceived,
    SnarkPoolCandidatePeerPrune,
    SnarkPoolCandidateWorkFetchAll,
    SnarkPoolCandidateWorkFetchInit,
    SnarkPoolCandidateWorkFetchPending,
    SnarkPoolCandidateWorkReceived,
    SnarkPoolCandidateWorkVerifyError,
    SnarkPoolCandidateWorkVerifyNext,
    SnarkPoolCandidateWorkVerifyPending,
    SnarkPoolCandidateWorkVerifySuccess,
    SnarkUserCommandVerifyError,
    SnarkUserCommandVerifyFinish,
    SnarkUserCommandVerifyInit,
    SnarkUserCommandVerifyPending,
    SnarkUserCommandVerifySuccess,
    SnarkWorkVerifyError,
    SnarkWorkVerifyFinish,
    SnarkWorkVerifyInit,
    SnarkWorkVerifyPending,
    SnarkWorkVerifySuccess,
    TransactionPoolApplyTransitionFrontierDiff,
    TransactionPoolApplyTransitionFrontierDiffWithAccounts,
    TransactionPoolApplyVerifiedDiff,
    TransactionPoolApplyVerifiedDiffWithAccounts,
    TransactionPoolBestTipChanged,
    TransactionPoolBestTipChangedWithAccounts,
    TransactionPoolRebroadcast,
    TransitionFrontierGenesisInject,
    TransitionFrontierSynced,
    TransitionFrontierGenesisLedgerLoadInit,
    TransitionFrontierGenesisLedgerLoadPending,
    TransitionFrontierGenesisLedgerLoadSuccess,
    TransitionFrontierGenesisProduce,
    TransitionFrontierGenesisProveInit,
    TransitionFrontierGenesisProvePending,
    TransitionFrontierGenesisProveSuccess,
    TransitionFrontierSyncBestTipUpdate,
    TransitionFrontierSyncBlocksFetchSuccess,
    TransitionFrontierSyncBlocksNextApplyInit,
    TransitionFrontierSyncBlocksNextApplyPending,
    TransitionFrontierSyncBlocksNextApplySuccess,
    TransitionFrontierSyncBlocksPeerQueryError,
    TransitionFrontierSyncBlocksPeerQueryInit,
    TransitionFrontierSyncBlocksPeerQueryPending,
    TransitionFrontierSyncBlocksPeerQueryRetry,
    TransitionFrontierSyncBlocksPeerQuerySuccess,
    TransitionFrontierSyncBlocksPeersQuery,
    TransitionFrontierSyncBlocksPending,
    TransitionFrontierSyncBlocksSuccess,
    TransitionFrontierSyncInit,
    TransitionFrontierSyncLedgerNextEpochPending,
    TransitionFrontierSyncLedgerNextEpochSuccess,
    TransitionFrontierSyncLedgerRootPending,
    TransitionFrontierSyncLedgerRootSuccess,
    TransitionFrontierSyncLedgerStakingPending,
    TransitionFrontierSyncLedgerStakingSuccess,
    TransitionFrontierSyncLedgerInit,
    TransitionFrontierSyncLedgerSuccess,
    TransitionFrontierSyncLedgerSnarkedChildAccountsAccepted,
    TransitionFrontierSyncLedgerSnarkedChildAccountsReceived,
    TransitionFrontierSyncLedgerSnarkedChildAccountsRejected,
    TransitionFrontierSyncLedgerSnarkedChildHashesAccepted,
    TransitionFrontierSyncLedgerSnarkedChildHashesReceived,
    TransitionFrontierSyncLedgerSnarkedChildHashesRejected,
    TransitionFrontierSyncLedgerSnarkedMerkleTreeSyncPending,
    TransitionFrontierSyncLedgerSnarkedMerkleTreeSyncSuccess,
    TransitionFrontierSyncLedgerSnarkedNumAccountsAccepted,
    TransitionFrontierSyncLedgerSnarkedNumAccountsReceived,
    TransitionFrontierSyncLedgerSnarkedNumAccountsRejected,
    TransitionFrontierSyncLedgerSnarkedNumAccountsSuccess,
    TransitionFrontierSyncLedgerSnarkedPeerQueryAddressError,
    TransitionFrontierSyncLedgerSnarkedPeerQueryAddressInit,
    TransitionFrontierSyncLedgerSnarkedPeerQueryAddressPending,
    TransitionFrontierSyncLedgerSnarkedPeerQueryAddressRetry,
    TransitionFrontierSyncLedgerSnarkedPeerQueryAddressSuccess,
    TransitionFrontierSyncLedgerSnarkedPeerQueryNumAccountsError,
    TransitionFrontierSyncLedgerSnarkedPeerQueryNumAccountsInit,
    TransitionFrontierSyncLedgerSnarkedPeerQueryNumAccountsPending,
    TransitionFrontierSyncLedgerSnarkedPeerQueryNumAccountsRetry,
    TransitionFrontierSyncLedgerSnarkedPeerQueryNumAccountsSuccess,
    TransitionFrontierSyncLedgerSnarkedPeersQuery,
    TransitionFrontierSyncLedgerSnarkedPending,
    TransitionFrontierSyncLedgerSnarkedSuccess,
    TransitionFrontierSyncLedgerStagedPartsFetchPending,
    TransitionFrontierSyncLedgerStagedPartsFetchSuccess,
    TransitionFrontierSyncLedgerStagedPartsPeerFetchError,
    TransitionFrontierSyncLedgerStagedPartsPeerFetchInit,
    TransitionFrontierSyncLedgerStagedPartsPeerFetchPending,
    TransitionFrontierSyncLedgerStagedPartsPeerFetchSuccess,
    TransitionFrontierSyncLedgerStagedPartsPeerInvalid,
    TransitionFrontierSyncLedgerStagedPartsPeerValid,
    TransitionFrontierSyncLedgerStagedReconstructEmpty,
    TransitionFrontierSyncLedgerStagedReconstructError,
    TransitionFrontierSyncLedgerStagedReconstructInit,
    TransitionFrontierSyncLedgerStagedReconstructPending,
    TransitionFrontierSyncLedgerStagedReconstructSuccess,
    TransitionFrontierSyncLedgerStagedSuccess,
    WatchedAccountsAdd,
    WatchedAccountsBlockLedgerQueryInit,
    WatchedAccountsBlockLedgerQueryPending,
    WatchedAccountsBlockLedgerQuerySuccess,
    WatchedAccountsLedgerInitialStateGetError,
    WatchedAccountsLedgerInitialStateGetInit,
    WatchedAccountsLedgerInitialStateGetPending,
    WatchedAccountsLedgerInitialStateGetRetry,
    WatchedAccountsLedgerInitialStateGetSuccess,
    WatchedAccountsTransactionsIncludedInBlock,
}

impl ActionKind {
    pub const COUNT: u16 = 352;
}

impl std::fmt::Display for ActionKind {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{self:?}")
    }
}

impl ActionKindGet for Action {
    fn kind(&self) -> ActionKind {
        match self {
            Self::CheckTimeouts(a) => a.kind(),
            Self::EventSource(a) => a.kind(),
            Self::P2p(a) => a.kind(),
            Self::Snark(a) => a.kind(),
            Self::Consensus(a) => a.kind(),
            Self::TransitionFrontier(a) => a.kind(),
            Self::SnarkPool(a) => a.kind(),
            Self::TransactionPool(a) => a.kind(),
            Self::ExternalSnarkWorker(a) => a.kind(),
            Self::BlockProducer(a) => a.kind(),
            Self::Rpc(a) => a.kind(),
            Self::WatchedAccounts(a) => a.kind(),
        }
    }
}

impl ActionKindGet for CheckTimeoutsAction {
    fn kind(&self) -> ActionKind {
        ActionKind::CheckTimeouts
    }
}

impl ActionKindGet for EventSourceAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::ProcessEvents => ActionKind::EventSourceProcessEvents,
            Self::NewEvent { .. } => ActionKind::EventSourceNewEvent,
            Self::WaitForEvents => ActionKind::EventSourceWaitForEvents,
            Self::WaitTimeout => ActionKind::EventSourceWaitTimeout,
        }
    }
}

impl ActionKindGet for P2pAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::Listen(a) => a.kind(),
            Self::Connection(a) => a.kind(),
            Self::Disconnection(a) => a.kind(),
            Self::Discovery(a) => a.kind(),
            Self::Channels(a) => a.kind(),
            Self::Peer(a) => a.kind(),
            Self::Network(a) => a.kind(),
        }
    }
}

impl ActionKindGet for SnarkAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::BlockVerify(a) => a.kind(),
            Self::WorkVerify(a) => a.kind(),
            Self::UserCommandVerify(a) => a.kind(),
        }
    }
}

impl ActionKindGet for ConsensusAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::BlockReceived { .. } => ActionKind::ConsensusBlockReceived,
            Self::BlockChainProofUpdate { .. } => ActionKind::ConsensusBlockChainProofUpdate,
            Self::BlockSnarkVerifyPending { .. } => ActionKind::ConsensusBlockSnarkVerifyPending,
            Self::BlockSnarkVerifySuccess { .. } => ActionKind::ConsensusBlockSnarkVerifySuccess,
            Self::DetectForkRange { .. } => ActionKind::ConsensusDetectForkRange,
            Self::ShortRangeForkResolve { .. } => ActionKind::ConsensusShortRangeForkResolve,
            Self::LongRangeForkResolve { .. } => ActionKind::ConsensusLongRangeForkResolve,
            Self::BestTipUpdate { .. } => ActionKind::ConsensusBestTipUpdate,
            Self::Prune => ActionKind::ConsensusPrune,
        }
    }
}

impl ActionKindGet for TransitionFrontierAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::Genesis(a) => a.kind(),
            Self::Sync(a) => a.kind(),
            Self::GenesisInject => ActionKind::TransitionFrontierGenesisInject,
            Self::Synced { .. } => ActionKind::TransitionFrontierSynced,
        }
    }
}

impl ActionKindGet for SnarkPoolAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::Candidate(a) => a.kind(),
            Self::JobsUpdate { .. } => ActionKind::SnarkPoolJobsUpdate,
            Self::AutoCreateCommitment => ActionKind::SnarkPoolAutoCreateCommitment,
            Self::CommitmentCreate { .. } => ActionKind::SnarkPoolCommitmentCreate,
            Self::CommitmentAdd { .. } => ActionKind::SnarkPoolCommitmentAdd,
            Self::WorkAdd { .. } => ActionKind::SnarkPoolWorkAdd,
            Self::P2pSendAll => ActionKind::SnarkPoolP2pSendAll,
            Self::P2pSend { .. } => ActionKind::SnarkPoolP2pSend,
            Self::CheckTimeouts => ActionKind::SnarkPoolCheckTimeouts,
            Self::JobCommitmentTimeout { .. } => ActionKind::SnarkPoolJobCommitmentTimeout,
        }
    }
}

impl ActionKindGet for TransactionPoolAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::BestTipChanged { .. } => ActionKind::TransactionPoolBestTipChanged,
            Self::BestTipChangedWithAccounts { .. } => {
                ActionKind::TransactionPoolBestTipChangedWithAccounts
            }
            Self::ApplyVerifiedDiff { .. } => ActionKind::TransactionPoolApplyVerifiedDiff,
            Self::ApplyVerifiedDiffWithAccounts { .. } => {
                ActionKind::TransactionPoolApplyVerifiedDiffWithAccounts
            }
            Self::ApplyTransitionFrontierDiff { .. } => {
                ActionKind::TransactionPoolApplyTransitionFrontierDiff
            }
            Self::ApplyTransitionFrontierDiffWithAccounts { .. } => {
                ActionKind::TransactionPoolApplyTransitionFrontierDiffWithAccounts
            }
            Self::Rebroadcast => ActionKind::TransactionPoolRebroadcast,
        }
    }
}

impl ActionKindGet for ExternalSnarkWorkerAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::Start => ActionKind::ExternalSnarkWorkerStart,
            Self::Started => ActionKind::ExternalSnarkWorkerStarted,
            Self::StartTimeout { .. } => ActionKind::ExternalSnarkWorkerStartTimeout,
            Self::Kill => ActionKind::ExternalSnarkWorkerKill,
            Self::Killed => ActionKind::ExternalSnarkWorkerKilled,
            Self::SubmitWork { .. } => ActionKind::ExternalSnarkWorkerSubmitWork,
            Self::WorkResult { .. } => ActionKind::ExternalSnarkWorkerWorkResult,
            Self::WorkError { .. } => ActionKind::ExternalSnarkWorkerWorkError,
            Self::WorkTimeout { .. } => ActionKind::ExternalSnarkWorkerWorkTimeout,
            Self::CancelWork => ActionKind::ExternalSnarkWorkerCancelWork,
            Self::WorkCancelled => ActionKind::ExternalSnarkWorkerWorkCancelled,
            Self::PruneWork => ActionKind::ExternalSnarkWorkerPruneWork,
            Self::Error { .. } => ActionKind::ExternalSnarkWorkerError,
        }
    }
}

impl ActionKindGet for BlockProducerAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::VrfEvaluator(a) => a.kind(),
            Self::BestTipUpdate { .. } => ActionKind::BlockProducerBestTipUpdate,
            Self::WonSlotSearch => ActionKind::BlockProducerWonSlotSearch,
            Self::WonSlot { .. } => ActionKind::BlockProducerWonSlot,
            Self::WonSlotDiscard { .. } => ActionKind::BlockProducerWonSlotDiscard,
            Self::WonSlotWait => ActionKind::BlockProducerWonSlotWait,
            Self::WonSlotProduceInit => ActionKind::BlockProducerWonSlotProduceInit,
            Self::StagedLedgerDiffCreateInit => ActionKind::BlockProducerStagedLedgerDiffCreateInit,
            Self::StagedLedgerDiffCreatePending => {
                ActionKind::BlockProducerStagedLedgerDiffCreatePending
            }
            Self::StagedLedgerDiffCreateSuccess { .. } => {
                ActionKind::BlockProducerStagedLedgerDiffCreateSuccess
            }
            Self::BlockUnprovenBuild => ActionKind::BlockProducerBlockUnprovenBuild,
            Self::BlockProveInit => ActionKind::BlockProducerBlockProveInit,
            Self::BlockProvePending => ActionKind::BlockProducerBlockProvePending,
            Self::BlockProveSuccess { .. } => ActionKind::BlockProducerBlockProveSuccess,
            Self::BlockProduced => ActionKind::BlockProducerBlockProduced,
            Self::BlockInject => ActionKind::BlockProducerBlockInject,
            Self::BlockInjected => ActionKind::BlockProducerBlockInjected,
        }
    }
}

impl ActionKindGet for RpcAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::GlobalStateGet { .. } => ActionKind::RpcGlobalStateGet,
            Self::ActionStatsGet { .. } => ActionKind::RpcActionStatsGet,
            Self::SyncStatsGet { .. } => ActionKind::RpcSyncStatsGet,
            Self::MessageProgressGet { .. } => ActionKind::RpcMessageProgressGet,
            Self::PeersGet { .. } => ActionKind::RpcPeersGet,
            Self::P2pConnectionOutgoingInit { .. } => ActionKind::RpcP2pConnectionOutgoingInit,
            Self::P2pConnectionOutgoingPending { .. } => {
                ActionKind::RpcP2pConnectionOutgoingPending
            }
            Self::P2pConnectionOutgoingError { .. } => ActionKind::RpcP2pConnectionOutgoingError,
            Self::P2pConnectionOutgoingSuccess { .. } => {
                ActionKind::RpcP2pConnectionOutgoingSuccess
            }
            Self::P2pConnectionIncomingInit { .. } => ActionKind::RpcP2pConnectionIncomingInit,
            Self::P2pConnectionIncomingPending { .. } => {
                ActionKind::RpcP2pConnectionIncomingPending
            }
            Self::P2pConnectionIncomingRespond { .. } => {
                ActionKind::RpcP2pConnectionIncomingRespond
            }
            Self::P2pConnectionIncomingError { .. } => ActionKind::RpcP2pConnectionIncomingError,
            Self::P2pConnectionIncomingSuccess { .. } => {
                ActionKind::RpcP2pConnectionIncomingSuccess
            }
            Self::ScanStateSummaryGet { .. } => ActionKind::RpcScanStateSummaryGet,
            Self::SnarkPoolAvailableJobsGet { .. } => ActionKind::RpcSnarkPoolAvailableJobsGet,
            Self::SnarkPoolJobGet { .. } => ActionKind::RpcSnarkPoolJobGet,
            Self::SnarkerConfigGet { .. } => ActionKind::RpcSnarkerConfigGet,
            Self::SnarkerJobCommit { .. } => ActionKind::RpcSnarkerJobCommit,
            Self::SnarkerJobSpec { .. } => ActionKind::RpcSnarkerJobSpec,
            Self::SnarkerWorkersGet { .. } => ActionKind::RpcSnarkerWorkersGet,
            Self::HealthCheck { .. } => ActionKind::RpcHealthCheck,
            Self::ReadinessCheck { .. } => ActionKind::RpcReadinessCheck,
            Self::DiscoveryRoutingTable { .. } => ActionKind::RpcDiscoveryRoutingTable,
            Self::DiscoveryBoostrapStats { .. } => ActionKind::RpcDiscoveryBoostrapStats,
            Self::Finish { .. } => ActionKind::RpcFinish,
        }
    }
}

impl ActionKindGet for WatchedAccountsAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::Add { .. } => ActionKind::WatchedAccountsAdd,
            Self::LedgerInitialStateGetInit { .. } => {
                ActionKind::WatchedAccountsLedgerInitialStateGetInit
            }
            Self::LedgerInitialStateGetPending { .. } => {
                ActionKind::WatchedAccountsLedgerInitialStateGetPending
            }
            Self::LedgerInitialStateGetError { .. } => {
                ActionKind::WatchedAccountsLedgerInitialStateGetError
            }
            Self::LedgerInitialStateGetRetry { .. } => {
                ActionKind::WatchedAccountsLedgerInitialStateGetRetry
            }
            Self::LedgerInitialStateGetSuccess { .. } => {
                ActionKind::WatchedAccountsLedgerInitialStateGetSuccess
            }
            Self::TransactionsIncludedInBlock { .. } => {
                ActionKind::WatchedAccountsTransactionsIncludedInBlock
            }
            Self::BlockLedgerQueryInit { .. } => ActionKind::WatchedAccountsBlockLedgerQueryInit,
            Self::BlockLedgerQueryPending { .. } => {
                ActionKind::WatchedAccountsBlockLedgerQueryPending
            }
            Self::BlockLedgerQuerySuccess { .. } => {
                ActionKind::WatchedAccountsBlockLedgerQuerySuccess
            }
        }
    }
}

impl ActionKindGet for P2pListenAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::New { .. } => ActionKind::P2pListenNew,
            Self::Expired { .. } => ActionKind::P2pListenExpired,
            Self::Error { .. } => ActionKind::P2pListenError,
            Self::Closed { .. } => ActionKind::P2pListenClosed,
        }
    }
}

impl ActionKindGet for P2pConnectionAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::Outgoing(a) => a.kind(),
            Self::Incoming(a) => a.kind(),
        }
    }
}

impl ActionKindGet for P2pDisconnectionAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::Init { .. } => ActionKind::P2pDisconnectionInit,
            Self::Finish { .. } => ActionKind::P2pDisconnectionFinish,
        }
    }
}

impl ActionKindGet for P2pDiscoveryAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::Init { .. } => ActionKind::P2pDiscoveryInit,
            Self::Success { .. } => ActionKind::P2pDiscoverySuccess,
            Self::KademliaBootstrap => ActionKind::P2pDiscoveryKademliaBootstrap,
            Self::KademliaInit => ActionKind::P2pDiscoveryKademliaInit,
            Self::KademliaAddRoute { .. } => ActionKind::P2pDiscoveryKademliaAddRoute,
            Self::KademliaSuccess { .. } => ActionKind::P2pDiscoveryKademliaSuccess,
            Self::KademliaFailure { .. } => ActionKind::P2pDiscoveryKademliaFailure,
        }
    }
}

impl ActionKindGet for P2pChannelsAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::MessageReceived(a) => a.kind(),
            Self::BestTip(a) => a.kind(),
            Self::Snark(a) => a.kind(),
            Self::SnarkJobCommitment(a) => a.kind(),
            Self::Rpc(a) => a.kind(),
        }
    }
}

impl ActionKindGet for P2pPeerAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::Ready { .. } => ActionKind::P2pPeerReady,
            Self::BestTipUpdate { .. } => ActionKind::P2pPeerBestTipUpdate,
        }
    }
}

impl ActionKindGet for P2pNetworkAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::Scheduler(a) => a.kind(),
            Self::Pnet(a) => a.kind(),
            Self::Select(a) => a.kind(),
            Self::Noise(a) => a.kind(),
            Self::Yamux(a) => a.kind(),
            Self::Kad(a) => a.kind(),
            Self::Rpc(a) => a.kind(),
        }
    }
}

impl ActionKindGet for SnarkBlockVerifyAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::Init { .. } => ActionKind::SnarkBlockVerifyInit,
            Self::Pending { .. } => ActionKind::SnarkBlockVerifyPending,
            Self::Error { .. } => ActionKind::SnarkBlockVerifyError,
            Self::Success { .. } => ActionKind::SnarkBlockVerifySuccess,
            Self::Finish { .. } => ActionKind::SnarkBlockVerifyFinish,
        }
    }
}

impl ActionKindGet for SnarkWorkVerifyAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::Init { .. } => ActionKind::SnarkWorkVerifyInit,
            Self::Pending { .. } => ActionKind::SnarkWorkVerifyPending,
            Self::Error { .. } => ActionKind::SnarkWorkVerifyError,
            Self::Success { .. } => ActionKind::SnarkWorkVerifySuccess,
            Self::Finish { .. } => ActionKind::SnarkWorkVerifyFinish,
        }
    }
}

impl ActionKindGet for SnarkUserCommandVerifyAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::Init { .. } => ActionKind::SnarkUserCommandVerifyInit,
            Self::Pending { .. } => ActionKind::SnarkUserCommandVerifyPending,
            Self::Error { .. } => ActionKind::SnarkUserCommandVerifyError,
            Self::Success { .. } => ActionKind::SnarkUserCommandVerifySuccess,
            Self::Finish { .. } => ActionKind::SnarkUserCommandVerifyFinish,
        }
    }
}

impl ActionKindGet for TransitionFrontierGenesisAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::LedgerLoadInit => ActionKind::TransitionFrontierGenesisLedgerLoadInit,
            Self::LedgerLoadPending => ActionKind::TransitionFrontierGenesisLedgerLoadPending,
            Self::LedgerLoadSuccess { .. } => {
                ActionKind::TransitionFrontierGenesisLedgerLoadSuccess
            }
            Self::Produce => ActionKind::TransitionFrontierGenesisProduce,
            Self::ProveInit => ActionKind::TransitionFrontierGenesisProveInit,
            Self::ProvePending => ActionKind::TransitionFrontierGenesisProvePending,
            Self::ProveSuccess { .. } => ActionKind::TransitionFrontierGenesisProveSuccess,
        }
    }
}

impl ActionKindGet for TransitionFrontierSyncAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::Ledger(a) => a.kind(),
            Self::Init { .. } => ActionKind::TransitionFrontierSyncInit,
            Self::BestTipUpdate { .. } => ActionKind::TransitionFrontierSyncBestTipUpdate,
            Self::LedgerStakingPending => ActionKind::TransitionFrontierSyncLedgerStakingPending,
            Self::LedgerStakingSuccess => ActionKind::TransitionFrontierSyncLedgerStakingSuccess,
            Self::LedgerNextEpochPending => {
                ActionKind::TransitionFrontierSyncLedgerNextEpochPending
            }
            Self::LedgerNextEpochSuccess => {
                ActionKind::TransitionFrontierSyncLedgerNextEpochSuccess
            }
            Self::LedgerRootPending => ActionKind::TransitionFrontierSyncLedgerRootPending,
            Self::LedgerRootSuccess => ActionKind::TransitionFrontierSyncLedgerRootSuccess,
            Self::BlocksPending => ActionKind::TransitionFrontierSyncBlocksPending,
            Self::BlocksPeersQuery => ActionKind::TransitionFrontierSyncBlocksPeersQuery,
            Self::BlocksPeerQueryInit { .. } => {
                ActionKind::TransitionFrontierSyncBlocksPeerQueryInit
            }
            Self::BlocksPeerQueryRetry { .. } => {
                ActionKind::TransitionFrontierSyncBlocksPeerQueryRetry
            }
            Self::BlocksPeerQueryPending { .. } => {
                ActionKind::TransitionFrontierSyncBlocksPeerQueryPending
            }
            Self::BlocksPeerQueryError { .. } => {
                ActionKind::TransitionFrontierSyncBlocksPeerQueryError
            }
            Self::BlocksPeerQuerySuccess { .. } => {
                ActionKind::TransitionFrontierSyncBlocksPeerQuerySuccess
            }
            Self::BlocksFetchSuccess { .. } => ActionKind::TransitionFrontierSyncBlocksFetchSuccess,
            Self::BlocksNextApplyInit => ActionKind::TransitionFrontierSyncBlocksNextApplyInit,
            Self::BlocksNextApplyPending { .. } => {
                ActionKind::TransitionFrontierSyncBlocksNextApplyPending
            }
            Self::BlocksNextApplySuccess { .. } => {
                ActionKind::TransitionFrontierSyncBlocksNextApplySuccess
            }
            Self::BlocksSuccess => ActionKind::TransitionFrontierSyncBlocksSuccess,
        }
    }
}

impl ActionKindGet for SnarkPoolCandidateAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::InfoReceived { .. } => ActionKind::SnarkPoolCandidateInfoReceived,
            Self::WorkFetchAll => ActionKind::SnarkPoolCandidateWorkFetchAll,
            Self::WorkFetchInit { .. } => ActionKind::SnarkPoolCandidateWorkFetchInit,
            Self::WorkFetchPending { .. } => ActionKind::SnarkPoolCandidateWorkFetchPending,
            Self::WorkReceived { .. } => ActionKind::SnarkPoolCandidateWorkReceived,
            Self::WorkVerifyNext => ActionKind::SnarkPoolCandidateWorkVerifyNext,
            Self::WorkVerifyPending { .. } => ActionKind::SnarkPoolCandidateWorkVerifyPending,
            Self::WorkVerifyError { .. } => ActionKind::SnarkPoolCandidateWorkVerifyError,
            Self::WorkVerifySuccess { .. } => ActionKind::SnarkPoolCandidateWorkVerifySuccess,
            Self::PeerPrune { .. } => ActionKind::SnarkPoolCandidatePeerPrune,
        }
    }
}

impl ActionKindGet for BlockProducerVrfEvaluatorAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::EvaluateSlot { .. } => ActionKind::BlockProducerVrfEvaluatorEvaluateSlot,
            Self::ProcessSlotEvaluationSuccess { .. } => {
                ActionKind::BlockProducerVrfEvaluatorProcessSlotEvaluationSuccess
            }
            Self::InitializeEvaluator { .. } => {
                ActionKind::BlockProducerVrfEvaluatorInitializeEvaluator
            }
            Self::FinalizeEvaluatorInitialization { .. } => {
                ActionKind::BlockProducerVrfEvaluatorFinalizeEvaluatorInitialization
            }
            Self::CheckEpochEvaluability { .. } => {
                ActionKind::BlockProducerVrfEvaluatorCheckEpochEvaluability
            }
            Self::InitializeEpochEvaluation { .. } => {
                ActionKind::BlockProducerVrfEvaluatorInitializeEpochEvaluation
            }
            Self::BeginDelegatorTableConstruction { .. } => {
                ActionKind::BlockProducerVrfEvaluatorBeginDelegatorTableConstruction
            }
            Self::FinalizeDelegatorTableConstruction { .. } => {
                ActionKind::BlockProducerVrfEvaluatorFinalizeDelegatorTableConstruction
            }
            Self::SelectInitialSlot { .. } => {
                ActionKind::BlockProducerVrfEvaluatorSelectInitialSlot
            }
            Self::BeginEpochEvaluation { .. } => {
                ActionKind::BlockProducerVrfEvaluatorBeginEpochEvaluation
            }
            Self::RecordLastBlockHeightInEpoch { .. } => {
                ActionKind::BlockProducerVrfEvaluatorRecordLastBlockHeightInEpoch
            }
            Self::ContinueEpochEvaluation { .. } => {
                ActionKind::BlockProducerVrfEvaluatorContinueEpochEvaluation
            }
            Self::FinishEpochEvaluation { .. } => {
                ActionKind::BlockProducerVrfEvaluatorFinishEpochEvaluation
            }
            Self::WaitForNextEvaluation { .. } => {
                ActionKind::BlockProducerVrfEvaluatorWaitForNextEvaluation
            }
            Self::CheckEpochBounds { .. } => ActionKind::BlockProducerVrfEvaluatorCheckEpochBounds,
            Self::CleanupOldSlots { .. } => ActionKind::BlockProducerVrfEvaluatorCleanupOldSlots,
        }
    }
}

impl ActionKindGet for P2pConnectionOutgoingAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::RandomInit => ActionKind::P2pConnectionOutgoingRandomInit,
            Self::Init { .. } => ActionKind::P2pConnectionOutgoingInit,
            Self::Reconnect { .. } => ActionKind::P2pConnectionOutgoingReconnect,
            Self::OfferSdpCreatePending { .. } => {
                ActionKind::P2pConnectionOutgoingOfferSdpCreatePending
            }
            Self::OfferSdpCreateError { .. } => {
                ActionKind::P2pConnectionOutgoingOfferSdpCreateError
            }
            Self::OfferSdpCreateSuccess { .. } => {
                ActionKind::P2pConnectionOutgoingOfferSdpCreateSuccess
            }
            Self::OfferReady { .. } => ActionKind::P2pConnectionOutgoingOfferReady,
            Self::OfferSendSuccess { .. } => ActionKind::P2pConnectionOutgoingOfferSendSuccess,
            Self::AnswerRecvPending { .. } => ActionKind::P2pConnectionOutgoingAnswerRecvPending,
            Self::AnswerRecvError { .. } => ActionKind::P2pConnectionOutgoingAnswerRecvError,
            Self::AnswerRecvSuccess { .. } => ActionKind::P2pConnectionOutgoingAnswerRecvSuccess,
            Self::FinalizePending { .. } => ActionKind::P2pConnectionOutgoingFinalizePending,
            Self::FinalizeError { .. } => ActionKind::P2pConnectionOutgoingFinalizeError,
            Self::FinalizeSuccess { .. } => ActionKind::P2pConnectionOutgoingFinalizeSuccess,
            Self::Timeout { .. } => ActionKind::P2pConnectionOutgoingTimeout,
            Self::Error { .. } => ActionKind::P2pConnectionOutgoingError,
            Self::Success { .. } => ActionKind::P2pConnectionOutgoingSuccess,
        }
    }
}

impl ActionKindGet for P2pConnectionIncomingAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::Init { .. } => ActionKind::P2pConnectionIncomingInit,
            Self::AnswerSdpCreatePending { .. } => {
                ActionKind::P2pConnectionIncomingAnswerSdpCreatePending
            }
            Self::AnswerSdpCreateError { .. } => {
                ActionKind::P2pConnectionIncomingAnswerSdpCreateError
            }
            Self::AnswerSdpCreateSuccess { .. } => {
                ActionKind::P2pConnectionIncomingAnswerSdpCreateSuccess
            }
            Self::AnswerReady { .. } => ActionKind::P2pConnectionIncomingAnswerReady,
            Self::AnswerSendSuccess { .. } => ActionKind::P2pConnectionIncomingAnswerSendSuccess,
            Self::FinalizePending { .. } => ActionKind::P2pConnectionIncomingFinalizePending,
            Self::FinalizeError { .. } => ActionKind::P2pConnectionIncomingFinalizeError,
            Self::FinalizeSuccess { .. } => ActionKind::P2pConnectionIncomingFinalizeSuccess,
            Self::Timeout { .. } => ActionKind::P2pConnectionIncomingTimeout,
            Self::Error { .. } => ActionKind::P2pConnectionIncomingError,
            Self::Success { .. } => ActionKind::P2pConnectionIncomingSuccess,
            Self::Libp2pReceived { .. } => ActionKind::P2pConnectionIncomingLibp2pReceived,
        }
    }
}

impl ActionKindGet for P2pChannelsMessageReceivedAction {
    fn kind(&self) -> ActionKind {
        ActionKind::P2pChannelsMessageReceived
    }
}

impl ActionKindGet for P2pChannelsBestTipAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::Init { .. } => ActionKind::P2pChannelsBestTipInit,
            Self::Pending { .. } => ActionKind::P2pChannelsBestTipPending,
            Self::Ready { .. } => ActionKind::P2pChannelsBestTipReady,
            Self::RequestSend { .. } => ActionKind::P2pChannelsBestTipRequestSend,
            Self::Received { .. } => ActionKind::P2pChannelsBestTipReceived,
            Self::RequestReceived { .. } => ActionKind::P2pChannelsBestTipRequestReceived,
            Self::ResponseSend { .. } => ActionKind::P2pChannelsBestTipResponseSend,
        }
    }
}

impl ActionKindGet for P2pChannelsSnarkAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::Init { .. } => ActionKind::P2pChannelsSnarkInit,
            Self::Pending { .. } => ActionKind::P2pChannelsSnarkPending,
            Self::Ready { .. } => ActionKind::P2pChannelsSnarkReady,
            Self::RequestSend { .. } => ActionKind::P2pChannelsSnarkRequestSend,
            Self::PromiseReceived { .. } => ActionKind::P2pChannelsSnarkPromiseReceived,
            Self::Received { .. } => ActionKind::P2pChannelsSnarkReceived,
            Self::RequestReceived { .. } => ActionKind::P2pChannelsSnarkRequestReceived,
            Self::ResponseSend { .. } => ActionKind::P2pChannelsSnarkResponseSend,
            Self::Libp2pReceived { .. } => ActionKind::P2pChannelsSnarkLibp2pReceived,
            Self::Libp2pBroadcast { .. } => ActionKind::P2pChannelsSnarkLibp2pBroadcast,
        }
    }
}

impl ActionKindGet for P2pChannelsSnarkJobCommitmentAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::Init { .. } => ActionKind::P2pChannelsSnarkJobCommitmentInit,
            Self::Pending { .. } => ActionKind::P2pChannelsSnarkJobCommitmentPending,
            Self::Ready { .. } => ActionKind::P2pChannelsSnarkJobCommitmentReady,
            Self::RequestSend { .. } => ActionKind::P2pChannelsSnarkJobCommitmentRequestSend,
            Self::PromiseReceived { .. } => {
                ActionKind::P2pChannelsSnarkJobCommitmentPromiseReceived
            }
            Self::Received { .. } => ActionKind::P2pChannelsSnarkJobCommitmentReceived,
            Self::RequestReceived { .. } => {
                ActionKind::P2pChannelsSnarkJobCommitmentRequestReceived
            }
            Self::ResponseSend { .. } => ActionKind::P2pChannelsSnarkJobCommitmentResponseSend,
        }
    }
}

impl ActionKindGet for P2pChannelsRpcAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::Init { .. } => ActionKind::P2pChannelsRpcInit,
            Self::Pending { .. } => ActionKind::P2pChannelsRpcPending,
            Self::Ready { .. } => ActionKind::P2pChannelsRpcReady,
            Self::RequestSend { .. } => ActionKind::P2pChannelsRpcRequestSend,
            Self::Timeout { .. } => ActionKind::P2pChannelsRpcTimeout,
            Self::ResponseReceived { .. } => ActionKind::P2pChannelsRpcResponseReceived,
            Self::RequestReceived { .. } => ActionKind::P2pChannelsRpcRequestReceived,
            Self::ResponseSend { .. } => ActionKind::P2pChannelsRpcResponseSend,
        }
    }
}

impl ActionKindGet for P2pNetworkSchedulerAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::InterfaceDetected { .. } => ActionKind::P2pNetworkSchedulerInterfaceDetected,
            Self::InterfaceExpired { .. } => ActionKind::P2pNetworkSchedulerInterfaceExpired,
            Self::IncomingConnectionIsReady { .. } => {
                ActionKind::P2pNetworkSchedulerIncomingConnectionIsReady
            }
            Self::IncomingDidAccept { .. } => ActionKind::P2pNetworkSchedulerIncomingDidAccept,
            Self::OutgoingDidConnect { .. } => ActionKind::P2pNetworkSchedulerOutgoingDidConnect,
            Self::IncomingDataIsReady { .. } => ActionKind::P2pNetworkSchedulerIncomingDataIsReady,
            Self::IncomingDataDidReceive { .. } => {
                ActionKind::P2pNetworkSchedulerIncomingDataDidReceive
            }
            Self::SelectDone { .. } => ActionKind::P2pNetworkSchedulerSelectDone,
            Self::SelectError { .. } => ActionKind::P2pNetworkSchedulerSelectError,
            Self::YamuxDidInit { .. } => ActionKind::P2pNetworkSchedulerYamuxDidInit,
            Self::Disconnect { .. } => ActionKind::P2pNetworkSchedulerDisconnect,
            Self::Error { .. } => ActionKind::P2pNetworkSchedulerError,
            Self::Disconnected { .. } => ActionKind::P2pNetworkSchedulerDisconnected,
        }
    }
}

impl ActionKindGet for P2pNetworkPnetAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::IncomingData { .. } => ActionKind::P2pNetworkPnetIncomingData,
            Self::OutgoingData { .. } => ActionKind::P2pNetworkPnetOutgoingData,
            Self::SetupNonce { .. } => ActionKind::P2pNetworkPnetSetupNonce,
        }
    }
}

impl ActionKindGet for P2pNetworkSelectAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::Init { .. } => ActionKind::P2pNetworkSelectInit,
            Self::IncomingData { .. } => ActionKind::P2pNetworkSelectIncomingData,
            Self::IncomingToken { .. } => ActionKind::P2pNetworkSelectIncomingToken,
            Self::OutgoingTokens { .. } => ActionKind::P2pNetworkSelectOutgoingTokens,
        }
    }
}

impl ActionKindGet for P2pNetworkNoiseAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::Init { .. } => ActionKind::P2pNetworkNoiseInit,
            Self::IncomingData { .. } => ActionKind::P2pNetworkNoiseIncomingData,
            Self::IncomingChunk { .. } => ActionKind::P2pNetworkNoiseIncomingChunk,
            Self::OutgoingChunk { .. } => ActionKind::P2pNetworkNoiseOutgoingChunk,
            Self::OutgoingData { .. } => ActionKind::P2pNetworkNoiseOutgoingData,
            Self::DecryptedData { .. } => ActionKind::P2pNetworkNoiseDecryptedData,
            Self::HandshakeDone { .. } => ActionKind::P2pNetworkNoiseHandshakeDone,
        }
    }
}

impl ActionKindGet for P2pNetworkYamuxAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::IncomingData { .. } => ActionKind::P2pNetworkYamuxIncomingData,
            Self::OutgoingData { .. } => ActionKind::P2pNetworkYamuxOutgoingData,
            Self::IncomingFrame { .. } => ActionKind::P2pNetworkYamuxIncomingFrame,
            Self::OutgoingFrame { .. } => ActionKind::P2pNetworkYamuxOutgoingFrame,
            Self::PingStream { .. } => ActionKind::P2pNetworkYamuxPingStream,
            Self::OpenStream { .. } => ActionKind::P2pNetworkYamuxOpenStream,
        }
    }
}

impl ActionKindGet for P2pNetworkKadAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::System(a) => a.kind(),
            Self::Bootstrap(a) => a.kind(),
            Self::Request(a) => a.kind(),
            Self::Stream(a) => a.kind(),
        }
    }
}

impl ActionKindGet for P2pNetworkRpcAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::Init { .. } => ActionKind::P2pNetworkRpcInit,
            Self::IncomingData { .. } => ActionKind::P2pNetworkRpcIncomingData,
            Self::IncomingMessage { .. } => ActionKind::P2pNetworkRpcIncomingMessage,
            Self::PrunePending { .. } => ActionKind::P2pNetworkRpcPrunePending,
            Self::OutgoingQuery { .. } => ActionKind::P2pNetworkRpcOutgoingQuery,
            Self::OutgoingResponse { .. } => ActionKind::P2pNetworkRpcOutgoingResponse,
            Self::OutgoingData { .. } => ActionKind::P2pNetworkRpcOutgoingData,
        }
    }
}

impl ActionKindGet for TransitionFrontierSyncLedgerAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::Snarked(a) => a.kind(),
            Self::Staged(a) => a.kind(),
            Self::Init => ActionKind::TransitionFrontierSyncLedgerInit,
            Self::Success => ActionKind::TransitionFrontierSyncLedgerSuccess,
        }
    }
}

impl ActionKindGet for P2pNetworkKademliaAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::AnswerFindNodeRequest { .. } => {
                ActionKind::P2pNetworkKademliaAnswerFindNodeRequest
            }
            Self::UpdateFindNodeRequest { .. } => {
                ActionKind::P2pNetworkKademliaUpdateFindNodeRequest
            }
            Self::StartBootstrap { .. } => ActionKind::P2pNetworkKademliaStartBootstrap,
            Self::BootstrapFinished => ActionKind::P2pNetworkKademliaBootstrapFinished,
        }
    }
}

impl ActionKindGet for P2pNetworkKadBootstrapAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::CreateRequests => ActionKind::P2pNetworkKadBootstrapCreateRequests,
            Self::RequestDone { .. } => ActionKind::P2pNetworkKadBootstrapRequestDone,
            Self::RequestError { .. } => ActionKind::P2pNetworkKadBootstrapRequestError,
        }
    }
}

impl ActionKindGet for P2pNetworkKadRequestAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::New { .. } => ActionKind::P2pNetworkKadRequestNew,
            Self::PeerIsConnecting { .. } => ActionKind::P2pNetworkKadRequestPeerIsConnecting,
            Self::MuxReady { .. } => ActionKind::P2pNetworkKadRequestMuxReady,
            Self::StreamIsCreating { .. } => ActionKind::P2pNetworkKadRequestStreamIsCreating,
            Self::StreamReady { .. } => ActionKind::P2pNetworkKadRequestStreamReady,
            Self::RequestSent { .. } => ActionKind::P2pNetworkKadRequestRequestSent,
            Self::ReplyReceived { .. } => ActionKind::P2pNetworkKadRequestReplyReceived,
            Self::Prune { .. } => ActionKind::P2pNetworkKadRequestPrune,
            Self::Error { .. } => ActionKind::P2pNetworkKadRequestError,
        }
    }
}

impl ActionKindGet for P2pNetworkKademliaStreamAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::New { .. } => ActionKind::P2pNetworkKademliaStreamNew,
            Self::IncomingData { .. } => ActionKind::P2pNetworkKademliaStreamIncomingData,
            Self::RemoteClose { .. } => ActionKind::P2pNetworkKademliaStreamRemoteClose,
            Self::WaitIncoming { .. } => ActionKind::P2pNetworkKademliaStreamWaitIncoming,
            Self::WaitOutgoing { .. } => ActionKind::P2pNetworkKademliaStreamWaitOutgoing,
            Self::SendRequest { .. } => ActionKind::P2pNetworkKademliaStreamSendRequest,
            Self::SendResponse { .. } => ActionKind::P2pNetworkKademliaStreamSendResponse,
            Self::OutgoingDataReady { .. } => ActionKind::P2pNetworkKademliaStreamOutgoingDataReady,
            Self::Close { .. } => ActionKind::P2pNetworkKademliaStreamClose,
            Self::Prune { .. } => ActionKind::P2pNetworkKademliaStreamPrune,
        }
    }
}

impl ActionKindGet for TransitionFrontierSyncLedgerSnarkedAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::Pending => ActionKind::TransitionFrontierSyncLedgerSnarkedPending,
            Self::PeersQuery => ActionKind::TransitionFrontierSyncLedgerSnarkedPeersQuery,
            Self::PeerQueryNumAccountsInit { .. } => {
                ActionKind::TransitionFrontierSyncLedgerSnarkedPeerQueryNumAccountsInit
            }
            Self::PeerQueryNumAccountsPending { .. } => {
                ActionKind::TransitionFrontierSyncLedgerSnarkedPeerQueryNumAccountsPending
            }
            Self::PeerQueryNumAccountsRetry { .. } => {
                ActionKind::TransitionFrontierSyncLedgerSnarkedPeerQueryNumAccountsRetry
            }
            Self::PeerQueryNumAccountsError { .. } => {
                ActionKind::TransitionFrontierSyncLedgerSnarkedPeerQueryNumAccountsError
            }
            Self::PeerQueryNumAccountsSuccess { .. } => {
                ActionKind::TransitionFrontierSyncLedgerSnarkedPeerQueryNumAccountsSuccess
            }
            Self::NumAccountsReceived { .. } => {
                ActionKind::TransitionFrontierSyncLedgerSnarkedNumAccountsReceived
            }
            Self::NumAccountsAccepted { .. } => {
                ActionKind::TransitionFrontierSyncLedgerSnarkedNumAccountsAccepted
            }
            Self::NumAccountsRejected { .. } => {
                ActionKind::TransitionFrontierSyncLedgerSnarkedNumAccountsRejected
            }
            Self::NumAccountsSuccess { .. } => {
                ActionKind::TransitionFrontierSyncLedgerSnarkedNumAccountsSuccess
            }
            Self::MerkleTreeSyncPending => {
                ActionKind::TransitionFrontierSyncLedgerSnarkedMerkleTreeSyncPending
            }
            Self::PeerQueryAddressInit { .. } => {
                ActionKind::TransitionFrontierSyncLedgerSnarkedPeerQueryAddressInit
            }
            Self::PeerQueryAddressPending { .. } => {
                ActionKind::TransitionFrontierSyncLedgerSnarkedPeerQueryAddressPending
            }
            Self::PeerQueryAddressRetry { .. } => {
                ActionKind::TransitionFrontierSyncLedgerSnarkedPeerQueryAddressRetry
            }
            Self::PeerQueryAddressError { .. } => {
                ActionKind::TransitionFrontierSyncLedgerSnarkedPeerQueryAddressError
            }
            Self::PeerQueryAddressSuccess { .. } => {
                ActionKind::TransitionFrontierSyncLedgerSnarkedPeerQueryAddressSuccess
            }
            Self::ChildHashesReceived { .. } => {
                ActionKind::TransitionFrontierSyncLedgerSnarkedChildHashesReceived
            }
            Self::ChildHashesAccepted { .. } => {
                ActionKind::TransitionFrontierSyncLedgerSnarkedChildHashesAccepted
            }
            Self::ChildHashesRejected { .. } => {
                ActionKind::TransitionFrontierSyncLedgerSnarkedChildHashesRejected
            }
            Self::ChildAccountsReceived { .. } => {
                ActionKind::TransitionFrontierSyncLedgerSnarkedChildAccountsReceived
            }
            Self::ChildAccountsAccepted { .. } => {
                ActionKind::TransitionFrontierSyncLedgerSnarkedChildAccountsAccepted
            }
            Self::ChildAccountsRejected { .. } => {
                ActionKind::TransitionFrontierSyncLedgerSnarkedChildAccountsRejected
            }
            Self::MerkleTreeSyncSuccess => {
                ActionKind::TransitionFrontierSyncLedgerSnarkedMerkleTreeSyncSuccess
            }
            Self::Success => ActionKind::TransitionFrontierSyncLedgerSnarkedSuccess,
        }
    }
}

impl ActionKindGet for TransitionFrontierSyncLedgerStagedAction {
    fn kind(&self) -> ActionKind {
        match self {
            Self::PartsFetchPending => {
                ActionKind::TransitionFrontierSyncLedgerStagedPartsFetchPending
            }
            Self::PartsPeerFetchInit => {
                ActionKind::TransitionFrontierSyncLedgerStagedPartsPeerFetchInit
            }
            Self::PartsPeerFetchPending { .. } => {
                ActionKind::TransitionFrontierSyncLedgerStagedPartsPeerFetchPending
            }
            Self::PartsPeerFetchError { .. } => {
                ActionKind::TransitionFrontierSyncLedgerStagedPartsPeerFetchError
            }
            Self::PartsPeerFetchSuccess { .. } => {
                ActionKind::TransitionFrontierSyncLedgerStagedPartsPeerFetchSuccess
            }
            Self::PartsPeerInvalid { .. } => {
                ActionKind::TransitionFrontierSyncLedgerStagedPartsPeerInvalid
            }
            Self::PartsPeerValid { .. } => {
                ActionKind::TransitionFrontierSyncLedgerStagedPartsPeerValid
            }
            Self::PartsFetchSuccess { .. } => {
                ActionKind::TransitionFrontierSyncLedgerStagedPartsFetchSuccess
            }
            Self::ReconstructEmpty => {
                ActionKind::TransitionFrontierSyncLedgerStagedReconstructEmpty
            }
            Self::ReconstructInit => ActionKind::TransitionFrontierSyncLedgerStagedReconstructInit,
            Self::ReconstructPending => {
                ActionKind::TransitionFrontierSyncLedgerStagedReconstructPending
            }
            Self::ReconstructError { .. } => {
                ActionKind::TransitionFrontierSyncLedgerStagedReconstructError
            }
            Self::ReconstructSuccess { .. } => {
                ActionKind::TransitionFrontierSyncLedgerStagedReconstructSuccess
            }
            Self::Success => ActionKind::TransitionFrontierSyncLedgerStagedSuccess,
        }
    }
}