Struct NodeService 

pub struct NodeService {

    pub rng_seed: [u8; 32],
    pub rng_ephemeral: XofReaderCoreWrapper<Shake256ReaderCore>,
    pub rng_static: XofReaderCoreWrapper<Shake256ReaderCore>,
    pub rng: StdRng,
    pub event_sender: UnboundedSender<Event>,
    pub event_receiver: EventReceiver,
    pub snark_block_proof_verify: UnboundedSender<Tracked<SnarkBlockVerifyArgs>>,
    pub ledger_manager: LedgerManager,
    pub snark_worker: Option<SnarkWorker>,
    pub block_producer: Option<BlockProducerService>,
    pub archive: Option<ArchiveService>,
    pub p2p: P2pServiceCtx,
    pub stats: Option<Stats>,
    pub rpc: RpcService,
    pub recorder: Recorder,
    pub replayer: Option<ReplayerState>,
    pub invariants_state: InvariantsState,
}

Fields

rng_seed: [u8; 32]

Master seed for deterministic random number generation.

rng_ephemeral: XofReaderCoreWrapper<Shake256ReaderCore>

XOF-based RNG for ephemeral keys (derived from seed + “ephemeral”).

rng_static: XofReaderCoreWrapper<Shake256ReaderCore>

XOF-based RNG for static operations (derived from seed + “static”).

rng: StdRng

Standard RNG for general-purpose randomness.

event_sender: UnboundedSender<Event>

Events sent on this channel are retrieved and processed in the event_source state machine defined in the mina-node crate.

event_receiver: EventReceiver

Channel for consuming events in the event source state machine.

snark_block_proof_verify: UnboundedSender<Tracked<SnarkBlockVerifyArgs>>

Channel for asynchronous block proof verification requests.

ledger_manager: LedgerManager

Manages ledger operations, database access, and staged ledger state.

snark_worker: Option<SnarkWorker>

SNARK proof worker for generating transaction proofs (enabled when node acts as SNARK worker).

block_producer: Option<BlockProducerService>

Block production service including VRF evaluation and block proving (enabled when node acts as block producer).

archive: Option<ArchiveService>

Archive service for storing full blockchain history (enabled when node acts as archive node).

p2p: P2pServiceCtx

P2P networking context (WebRTC and optionally libp2p transports).

stats: Option<Stats>

Runtime statistics and metrics collection.

rpc: RpcService

RPC service for external API queries.

recorder: Recorder

Records node state and actions for debugging and replay.

replayer: Option<ReplayerState>

Replayer state for deterministic action replay (only set in replay mode).

invariants_state: InvariantsState

State for runtime invariant checking and validation.

Implementations

impl NodeService

pub fn process_rpc_request(&mut self, req: NodeRpcRequest)

impl NodeService

pub fn snark_block_proof_verifier_spawn( event_sender: UnboundedSender<Event>, ) -> UnboundedSender<Tracked<SnarkBlockVerifyArgs>>

impl NodeService

pub fn event_sender(&self) -> &UnboundedSender<Event>

pub fn rpc_sender(&self) -> RpcSender

pub fn event_receiver_with_rpc_receiver( &mut self, ) -> (&mut EventReceiver, &mut Receiver<NodeRpcRequest>)

pub fn event_receiver(&mut self) -> &mut EventReceiver

pub fn rpc_receiver(&mut self) -> &mut Receiver<NodeRpcRequest>

pub fn ledger_manager(&self) -> &LedgerManager

pub fn block_producer(&self) -> Option<&BlockProducerService>

pub fn archive(&self) -> Option<&ArchiveService>

pub fn stats(&mut self) -> Option<&mut Stats>

pub fn replayer(&mut self) -> Option<&mut ReplayerState>

impl NodeService

pub fn for_replay( rng_seed: [u8; 32], initial_time: Timestamp, p2p_sec_key: SecretKey, dynamic_effects_lib: Option<String>, ) -> NodeService

Trait Implementations

impl ArchiveService for NodeService

fn send_to_archive(&mut self, data: BlockApplyResult)

impl AsMut<NodeService> for NodeService

fn as_mut(&mut self) -> &mut NodeService

Converts this type into a mutable reference of the (usually inferred) input type.

impl BlockProducerService for NodeService

fn provers(&self) -> BlockProver

fn prove( &mut self, block_hash: Base58CheckOfBinProt<DataHashLibStateHashStableV1, Versioned<DataHashLibStateHashStableV1, 1>, mina_p2p_messages::::v2::manual::StateHash::{constant#1}>, input: Box<ProverExtendBlockchainInputStableV2>, )

fn with_producer_keypair<T>( &self, f: impl FnOnce(&AccountSecretKey) -> T, ) -> Option<T>

impl BlockProducerVrfEvaluatorService for NodeService

fn evaluate(&mut self, data: VrfEvaluatorInput)

impl EventSourceService for NodeService

fn next_event(&mut self) -> Option<Event>

impl ExternalSnarkWorkerService for NodeService

fn start( &mut self, pub_key: Base58CheckOfBinProt<NonZeroCurvePointUncompressedStableV1, Versioned<NonZeroCurvePointWithVersions, 1>, mina_p2p_messages::::v2::manual::NonZeroCurvePoint::{constant#1}>, fee: CurrencyFeeStableV1, work_verifier: TransactionVerifier, ) -> Result<(), ExternalSnarkWorkerError>

Starts external process.

fn kill(&mut self) -> Result<(), ExternalSnarkWorkerError>

Kills external process.

fn submit( &mut self, spec: SnarkWorkerWorkerRpcsVersionedGetWorkV2TResponseA0Instances, ) -> Result<(), ExternalSnarkWorkerError>

Submits snark work

fn cancel(&mut self) -> Result<(), ExternalSnarkWorkerError>

Cancel current work

impl InvariantService for NodeService

type ClusterInvariantsState<'a> = RefMut<'a, InvariantsState>

fn invariants_state(&mut self) -> &mut InvariantsState

fn node_id(&self) -> usize

fn cluster_invariants_state<'a>( &'a mut self, ) -> Option<Self::ClusterInvariantsState<'a>>

where Self: 'a,

impl LedgerService for NodeService

fn ledger_manager(&self) -> &LedgerManager

fn force_sync_calls(&self) -> bool

fn write_init(&mut self, request: LedgerWriteRequest)

fn read_init( &mut self, id: RequestId<LedgerReadIdType>, request: LedgerReadRequest, )

impl P2pCryptoService for NodeService

Available on crate feature p2p-libp2p only.

fn generate_random_nonce(&mut self) -> [u8; 24]

fn ephemeral_sk(&mut self) -> [u8; 32]

fn static_sk(&mut self) -> [u8; 32]

fn sign_key(&mut self, key: &[u8; 32]) -> Vec<u8>

fn sign_publication(&mut self, publication: &[u8]) -> Vec<u8>

fn verify_publication( &mut self, pk: &PublicKey, publication: &[u8], sig: &[u8], ) -> bool

impl P2pServiceWebrtc for NodeService

type Event = Event

fn random_pick( &mut self, list: &[P2pConnectionOutgoingInitOpts], ) -> Option<P2pConnectionOutgoingInitOpts>

fn event_sender( &self, ) -> &UnboundedSender<<NodeService as P2pServiceWebrtc>::Event>

fn cmd_sender(&self) -> &UnboundedSender<Tracked<Cmd>>

fn peers(&mut self) -> &mut BTreeMap<PeerId, PeerState>

fn encrypt<T>( &mut self, other_pk: &PublicKey, message: &T, ) -> Result<<T as EncryptableType>::Encrypted, Box<dyn Error>>

where T: EncryptableType,

fn decrypt<T>( &mut self, other_pk: &PublicKey, encrypted: &<T as EncryptableType>::Encrypted, ) -> Result<T, Box<dyn Error>>

where T: EncryptableType,

fn auth_encrypt_and_send( &mut self, peer_id: PeerId, other_pub_key: &PublicKey, auth: ConnectionAuth, )

fn auth_decrypt( &mut self, other_pub_key: &PublicKey, auth: ConnectionAuthEncrypted, ) -> Option<ConnectionAuth>

fn init<S>( secret_key: SecretKey, spawner: S, rng_seed: [u8; 32], ) -> P2pServiceCtx

where S: TaskSpawner,

fn outgoing_init(&mut self, peer_id: PeerId)

fn incoming_init(&mut self, peer_id: PeerId, offer: Offer)

fn set_answer(&mut self, peer_id: PeerId, answer: Answer)

fn http_signaling_request(&mut self, url: String, offer: Offer)

fn disconnect(&mut self, peer_id: PeerId) -> bool

fn channel_open(&mut self, peer_id: PeerId, id: ChannelId)

fn channel_send(&mut self, peer_id: PeerId, msg_id: MsgId, msg: ChannelMsg)

fn auth_send( &mut self, peer_id: PeerId, _other_pub_key: &PublicKey, auth: Option<ConnectionAuthEncrypted>, )

impl P2pServiceWebrtcWithLibp2p for NodeService

fn mio(&mut self) -> &mut MioService

fn connections(&self) -> BTreeSet<PeerId>

fn init<S>(sec_key: SecretKey, spawner: S, rng_seed: [u8; 32]) -> P2pServiceCtx

where S: TaskSpawner,

fn resolve_name( &mut self, hostname: &str, ) -> Result<Vec<IpAddr>, P2pNetworkServiceError>

fn detect_local_ip(&mut self) -> Result<Vec<IpAddr>, P2pNetworkServiceError>

impl RpcService for NodeService

fn respond_state_get( &mut self, rpc_id: RequestId<RpcIdType>, _: (&State, Option<&str>), ) -> Result<(), RespondError>

fn respond_status_get( &mut self, rpc_id: RequestId<RpcIdType>, response: Option<RpcNodeStatus>, ) -> Result<(), RespondError>

fn respond_heartbeat_get( &mut self, rpc_id: RequestId<RpcIdType>, response: Option<SignedNodeHeartbeat>, ) -> Result<(), RespondError>

fn respond_sync_stats_get( &mut self, rpc_id: RequestId<RpcIdType>, response: Option<Vec<SyncStatsSnapshot>>, ) -> Result<(), RespondError>

fn respond_action_stats_get( &mut self, rpc_id: RequestId<RpcIdType>, response: Option<ActionStatsResponse>, ) -> Result<(), RespondError>

fn respond_block_producer_stats_get( &mut self, rpc_id: RequestId<RpcIdType>, response: Option<RpcBlockProducerStats>, ) -> Result<(), RespondError>

fn respond_message_progress_stats_get( &mut self, rpc_id: RequestId<RpcIdType>, response: RpcMessageProgressResponse, ) -> Result<(), RespondError>

fn respond_peers_get( &mut self, rpc_id: RequestId<RpcIdType>, response: Vec<RpcPeerInfo>, ) -> Result<(), RespondError>

fn respond_p2p_connection_outgoing( &mut self, rpc_id: RequestId<RpcIdType>, response: Result<(), String>, ) -> Result<(), RespondError>

fn respond_p2p_connection_incoming_answer( &mut self, rpc_id: RequestId<RpcIdType>, response: P2pConnectionResponse, ) -> Result<(), RespondError>

fn respond_p2p_connection_incoming( &mut self, rpc_id: RequestId<RpcIdType>, response: Result<(), String>, ) -> Result<(), RespondError>

fn respond_scan_state_summary_get( &mut self, rpc_id: RequestId<RpcIdType>, response: Result<RpcScanStateSummary, String>, ) -> Result<(), RespondError>

fn respond_snark_pool_get( &mut self, rpc_id: RequestId<RpcIdType>, response: Vec<RpcSnarkPoolJobSummary>, ) -> Result<(), RespondError>

fn respond_snark_pool_job_get( &mut self, rpc_id: RequestId<RpcIdType>, response: Option<RpcSnarkPoolJobFull>, ) -> Result<(), RespondError>

fn respond_snark_pool_completed_jobs_get( &mut self, rpc_id: RequestId<RpcIdType>, response: Vec<TransactionSnarkWorkTStableV2>, ) -> Result<(), RespondError>

fn respond_snark_pool_pending_jobs_get( &mut self, rpc_id: RequestId<RpcIdType>, response: Vec<JobState>, ) -> Result<(), RespondError>

fn respond_snarker_job_commit( &mut self, rpc_id: RequestId<RpcIdType>, response: RpcSnarkerJobCommitResponse, ) -> Result<(), RespondError>

fn respond_snarker_job_spec( &mut self, rpc_id: RequestId<RpcIdType>, response: RpcSnarkerJobSpecResponse, ) -> Result<(), RespondError>

fn respond_snarker_workers( &mut self, rpc_id: RequestId<RpcIdType>, response: Vec<RpcSnarkWorker>, ) -> Result<(), RespondError>

fn respond_snarker_config_get( &mut self, rpc_id: RequestId<RpcIdType>, response: Option<RpcSnarkerConfig>, ) -> Result<(), RespondError>

fn respond_health_check( &mut self, rpc_id: RequestId<RpcIdType>, response: Result<(), String>, ) -> Result<(), RespondError>

fn respond_readiness_check( &mut self, rpc_id: RequestId<RpcIdType>, response: Result<(), String>, ) -> Result<(), RespondError>

fn respond_discovery_routing_table( &mut self, rpc_id: RequestId<RpcIdType>, response: Option<RpcDiscoveryRoutingTable>, ) -> Result<(), RespondError>

fn respond_discovery_bootstrap_stats( &mut self, rpc_id: RequestId<RpcIdType>, response: Option<P2pNetworkKadBootstrapStats>, ) -> Result<(), RespondError>

fn respond_transaction_pool( &mut self, rpc_id: RequestId<RpcIdType>, response: Vec<WithHash<UserCommand, TransactionHash>>, ) -> Result<(), RespondError>

fn respond_ledger_slim_accounts( &mut self, rpc_id: RequestId<RpcIdType>, response: Vec<AccountSlim>, ) -> Result<(), RespondError>

fn respond_ledger_accounts( &mut self, rpc_id: RequestId<RpcIdType>, response: Vec<Account>, ) -> Result<(), RespondError>

fn respond_transaction_inject( &mut self, rpc_id: RequestId<RpcIdType>, response: RpcTransactionInjectResponse, ) -> Result<(), RespondError>

fn respond_transition_frontier_commands( &mut self, rpc_id: RequestId<RpcIdType>, response: Vec<MinaBaseUserCommandStableV2>, ) -> Result<(), RespondError>

fn respond_best_chain( &mut self, rpc_id: RequestId<RpcIdType>, response: Vec<AppliedBlock>, ) -> Result<(), RespondError>

fn respond_consensus_constants( &mut self, rpc_id: RequestId<RpcIdType>, response: ConsensusConstants, ) -> Result<(), RespondError>

fn respond_transaction_status( &mut self, rpc_id: RequestId<RpcIdType>, response: TransactionStatus, ) -> Result<(), RespondError>

fn respond_block_get( &mut self, rpc_id: RequestId<RpcIdType>, response: Option<AppliedBlock>, ) -> Result<(), RespondError>

fn respond_pooled_user_commands( &mut self, rpc_id: RequestId<RpcIdType>, response: Vec<MinaBaseSignedCommandStableV2>, ) -> Result<(), RespondError>

fn respond_pooled_zkapp_commands( &mut self, rpc_id: RequestId<RpcIdType>, response: Vec<MinaBaseZkappCommandTStableV1WireStableV1>, ) -> Result<(), RespondError>

fn respond_genesis_block( &mut self, rpc_id: RequestId<RpcIdType>, response: Option<BlockWithHash<Arc<MinaBlockBlockStableV2>>>, ) -> Result<(), RespondError>

fn respond_consensus_time_get( &mut self, rpc_id: RequestId<RpcIdType>, response: Option<ConsensusTime>, ) -> Result<(), RespondError>

fn respond_ledger_status_get( &mut self, rpc_id: RequestId<RpcIdType>, response: Option<LedgerStatus>, ) -> Result<(), RespondError>

fn respond_ledger_account_delegators_get( &mut self, rpc_id: RequestId<RpcIdType>, response: Option<Vec<Account>>, ) -> Result<(), RespondError>

impl Service for NodeService

fn queues(&mut self) -> Queues

fn stats(&mut self) -> Option<&mut Stats>

fn recorder(&mut self) -> &mut Recorder

fn is_replay(&self) -> bool

impl SnarkBlockVerifyService for NodeService

fn verify_init( &mut self, req_id: RequestId<SnarkBlockVerifyIdType>, verifier_index: BlockVerifier, verifier_srs: Arc<SRS<Affine<VestaParameters>>>, block: VerifiableBlockWithHash, )

impl SnarkPoolService for NodeService

fn random_choose<'a>( &mut self, iter: impl Iterator<Item = &'a LedgerHashTransition>, n: usize, ) -> Vec<LedgerHashTransition>

impl SnarkUserCommandVerifyService for NodeService

fn verify_init( &mut self, req_id: RequestId<SnarkUserCommandVerifyIdType>, commands: Vec<WithStatus<UserCommand>>, )

impl SnarkWorkVerifyService for NodeService

fn verify_init( &mut self, req_id: RequestId<SnarkWorkVerifyIdType>, verifier_index: TransactionVerifier, verifier_srs: Arc<SRS<Affine<VestaParameters>>>, work: Vec<Snark>, )

impl TimeService for NodeService

fn monotonic_time(&mut self) -> Instant

impl TransitionFrontierGenesisService for NodeService

fn load_genesis(&mut self, config: Arc<GenesisConfig>)

Load genesis config and genesis ledger.

impl Service for NodeService