Struct NodeService

Source

pub struct NodeService {Show 17 fields
    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]§rng_ephemeral: XofReaderCoreWrapper<Shake256ReaderCore>§rng_static: XofReaderCoreWrapper<Shake256ReaderCore>§rng: StdRng§event_sender: UnboundedSender<Event>

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

§event_receiver: EventReceiver§snark_block_proof_verify: UnboundedSender<Tracked<SnarkBlockVerifyArgs>>§ledger_manager: LedgerManager§snark_worker: Option<SnarkWorker>§block_producer: Option<BlockProducerService>§archive: Option<ArchiveService>§p2p: P2pServiceCtx§stats: Option<Stats>§rpc: RpcService§recorder: Recorder§replayer: Option<ReplayerState>§invariants_state: InvariantsState

Struct NodeServiceCopy item path

Fields§

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

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 kill(&mut self) -> Result<(), ExternalSnarkWorkerError>

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

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

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

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], ) -> P2pServiceCtxwhere 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]) -> P2pServiceCtxwhere 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

Struct NodeService

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

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 init<S>( secret_key: SecretKey, spawner: S, rng_seed: [u8; 32], ) -> P2pServiceCtx
where S: TaskSpawner,

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