Struct NodeTestingService 

pub struct NodeTestingService {
    real: NodeService,
    id: ClusterNodeId,
    rust_to_rust_use_webrtc: bool,
    proof_kind: ProofKind,
    is_replay: bool,
    monotonic_time: Instant,
    pending_events: PendingEvents,
    dyn_effects: Option<DynEffects>,
    snarker_sok_digest: Option<ByteString>,
    cluster_invariants_state: Arc<Mutex<InvariantsState>>,
    _shutdown: Aborter,
}

Fields

real: NodeService

id: ClusterNodeId

rust_to_rust_use_webrtc: bool

Use webrtc p2p between Rust nodes.

proof_kind: ProofKind

is_replay: bool

We are replaying this node so disable some non-deterministic services.

monotonic_time: Instant

pending_events: PendingEvents

Events sent by the real service not yet received by state machine.

dyn_effects: Option<DynEffects>

snarker_sok_digest: Option<ByteString>

cluster_invariants_state: Arc<Mutex<InvariantsState>>

_shutdown: Aborter

Once dropped, it will cause all threads associated to shutdown.

Implementations

impl NodeTestingService

pub fn new( real: NodeService, id: ClusterNodeId, cluster_invariants_state: Arc<StdMutex<InvariantsState>>, _shutdown: Aborter, ) -> Self

pub fn node_id(&self) -> ClusterNodeId

pub fn rust_to_rust_use_webrtc(&self) -> bool

pub fn set_rust_to_rust_use_webrtc(&mut self) -> &mut Self

pub fn proof_kind(&self) -> ProofKind

pub fn set_proof_kind(&mut self, kind: ProofKind) -> &mut Self

pub fn set_replay(&mut self) -> &mut Self

pub fn advance_time(&mut self, by_nanos: u64)

pub fn dyn_effects(&mut self, state: &State, action: &ActionWithMeta)

pub fn set_dyn_effects(&mut self, effects: DynEffects)

pub fn remove_dyn_effects(&mut self) -> Option<DynEffects>

pub fn set_snarker_sok_digest(&mut self, digest: ByteString)

pub fn pending_events( &mut self, poll: bool, ) -> impl Iterator<Item = (PendingEventId, &Event)>

pub async fn next_pending_event(&mut self) -> Option<(PendingEventId, &Event)>

pub fn get_pending_event(&self, id: PendingEventId) -> Option<&Event>

pub fn take_pending_event(&mut self, id: PendingEventId) -> Option<Event>

pub fn ledger(&self, ledger_hash: &LedgerHash) -> Option<Mask>

Trait Implementations

impl ArchiveService for NodeTestingService

fn send_to_archive(&mut self, data: BlockApplyResult)

impl BlockProducerService for NodeTestingService

fn provers(&self) -> BlockProver

fn prove( &mut self, block_hash: StateHash, input: Box<ProverExtendBlockchainInputStableV2>, )

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

impl BlockProducerVrfEvaluatorService for NodeTestingService

fn evaluate(&mut self, data: VrfEvaluatorInput)

impl EventSourceService for NodeTestingService

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

impl ExternalSnarkWorkerService for NodeTestingService

fn start( &mut self, public_key: NonZeroCurvePoint, fee: CurrencyFeeStableV1, _: TransactionVerifier, ) -> Result<(), ExternalSnarkWorkerError>

Starts external process.

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

Submits snark work

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

Cancel current work

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

Kills external process.

impl InvariantService for NodeTestingService

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

fn node_id(&self) -> usize

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

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

where Self: 'a,

impl LedgerService for NodeTestingService

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 NodeTestingService

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 NodeTestingService

type Event = Event

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

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

fn cmd_sender(&self) -> &TrackedUnboundedSender<Cmd>

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

fn outgoing_init(&mut self, peer_id: PeerId)

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

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

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

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 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 NodeTestingService

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 NodeTestingService

fn respond_state_get( &mut self, rpc_id: RpcId, response: (&State, Option<&str>), ) -> Result<(), RespondError>

fn respond_status_get( &mut self, rpc_id: RpcId, response: RpcStatusGetResponse, ) -> Result<(), RespondError>

fn respond_heartbeat_get( &mut self, rpc_id: RpcId, response: RpcHeartbeatGetResponse, ) -> Result<(), RespondError>

fn respond_sync_stats_get( &mut self, rpc_id: RpcId, response: RpcSyncStatsGetResponse, ) -> Result<(), RespondError>

fn respond_block_producer_stats_get( &mut self, rpc_id: RpcId, response: RpcBlockProducerStatsGetResponse, ) -> Result<(), RespondError>

fn respond_action_stats_get( &mut self, rpc_id: RpcId, response: RpcActionStatsGetResponse, ) -> Result<(), RespondError>

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

fn respond_peers_get( &mut self, rpc_id: RpcId, response: RpcPeersGetResponse, ) -> Result<(), RespondError>

fn respond_p2p_connection_outgoing( &mut self, rpc_id: RpcId, response: RpcP2pConnectionOutgoingResponse, ) -> Result<(), RespondError>

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

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

fn respond_scan_state_summary_get( &mut self, rpc_id: RpcId, response: RpcScanStateSummaryGetResponse, ) -> Result<(), RespondError>

fn respond_snark_pool_get( &mut self, rpc_id: RpcId, response: RpcSnarkPoolGetResponse, ) -> Result<(), RespondError>

fn respond_snark_pool_job_get( &mut self, rpc_id: RpcId, response: RpcSnarkPoolJobGetResponse, ) -> Result<(), RespondError>

fn respond_snark_pool_completed_jobs_get( &mut self, rpc_id: RpcId, response: RpcSnarkPoolCompletedJobsResponse, ) -> Result<(), RespondError>

fn respond_snark_pool_pending_jobs_get( &mut self, rpc_id: RpcId, response: RpcSnarkPoolPendingJobsGetResponse, ) -> Result<(), RespondError>

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

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

fn respond_snarker_workers( &mut self, rpc_id: RpcId, response: RpcSnarkerWorkersResponse, ) -> Result<(), RespondError>

fn respond_snarker_config_get( &mut self, rpc_id: RpcId, response: RpcSnarkerConfigGetResponse, ) -> Result<(), RespondError>

fn respond_health_check( &mut self, rpc_id: RpcId, response: RpcHealthCheckResponse, ) -> Result<(), RespondError>

fn respond_readiness_check( &mut self, rpc_id: RpcId, response: RpcReadinessCheckResponse, ) -> Result<(), RespondError>

fn respond_discovery_routing_table( &mut self, rpc_id: RpcId, response: RpcDiscoveryRoutingTableResponse, ) -> Result<(), RespondError>

fn respond_discovery_bootstrap_stats( &mut self, rpc_id: RpcId, response: RpcDiscoveryBoostrapStatsResponse, ) -> Result<(), RespondError>

fn respond_transaction_pool( &mut self, rpc_id: RpcId, response: RpcTransactionPoolResponse, ) -> Result<(), RespondError>

fn respond_ledger_slim_accounts( &mut self, rpc_id: RpcId, response: RpcLedgerSlimAccountsResponse, ) -> Result<(), RespondError>

fn respond_ledger_accounts( &mut self, rpc_id: RpcId, response: RpcLedgerAccountsResponse, ) -> Result<(), RespondError>

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

fn respond_transition_frontier_commands( &mut self, rpc_id: RpcId, response: RpcTransitionFrontierUserCommandsResponse, ) -> Result<(), RespondError>

fn respond_best_chain( &mut self, rpc_id: RpcId, response: RpcBestChainResponse, ) -> Result<(), RespondError>

fn respond_consensus_constants( &mut self, rpc_id: RpcId, response: RpcConsensusConstantsGetResponse, ) -> Result<(), RespondError>

fn respond_transaction_status( &mut self, rpc_id: RpcId, response: RpcTransactionStatusGetResponse, ) -> Result<(), RespondError>

fn respond_block_get( &mut self, rpc_id: RpcId, response: RpcGetBlockResponse, ) -> Result<(), RespondError>

fn respond_pooled_user_commands( &mut self, rpc_id: RpcId, response: RpcPooledUserCommandsResponse, ) -> Result<(), RespondError>

fn respond_pooled_zkapp_commands( &mut self, rpc_id: RpcId, response: RpcPooledZkappCommandsResponse, ) -> Result<(), RespondError>

fn respond_genesis_block( &mut self, rpc_id: RpcId, response: RpcGenesisBlockResponse, ) -> Result<(), RespondError>

fn respond_consensus_time_get( &mut self, rpc_id: RpcId, response: RpcConsensusTimeGetResponse, ) -> Result<(), RespondError>

fn respond_ledger_status_get( &mut self, rpc_id: RpcId, response: RpcLedgerStatusGetResponse, ) -> Result<(), RespondError>

fn respond_ledger_account_delegators_get( &mut self, rpc_id: RpcId, response: RpcLedgerAccountDelegatorsGetResponse, ) -> Result<(), RespondError>

impl Service for NodeTestingService

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 NodeTestingService

fn verify_init( &mut self, req_id: SnarkBlockVerifyId, verifier_index: BlockVerifier, verifier_srs: Arc<VerifierSRS>, block: VerifiableBlockWithHash, )

impl SnarkPoolService for NodeTestingService

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

impl SnarkUserCommandVerifyService for NodeTestingService

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

impl SnarkWorkVerifyService for NodeTestingService

fn verify_init( &mut self, req_id: SnarkWorkVerifyId, verifier_index: TransactionVerifier, verifier_srs: Arc<VerifierSRS>, work: Vec<Snark>, )

impl TimeService for NodeTestingService

fn monotonic_time(&mut self) -> Instant

impl TransitionFrontierGenesisService for NodeTestingService

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

Load genesis config and genesis ledger.

impl Service for NodeTestingService