1use anemo::Network;
5use anemo::PeerId;
6use anemo_tower::callback::CallbackLayer;
7use anemo_tower::trace::DefaultMakeSpan;
8use anemo_tower::trace::DefaultOnFailure;
9use anemo_tower::trace::TraceLayer;
10use anyhow::Context;
11use anyhow::Result;
12use anyhow::anyhow;
13use arc_swap::ArcSwap;
14use fastcrypto_zkp::bn254::zk_login::JwkId;
15use fastcrypto_zkp::bn254::zk_login::OIDCProvider;
16use futures::FutureExt;
17use futures::future::BoxFuture;
18use mysten_common::debug_fatal;
19use mysten_common::in_test_configuration;
20use prometheus::Registry;
21use std::collections::{BTreeSet, HashMap, HashSet};
22use std::fmt;
23use std::future::Future;
24use std::path::Path;
25use std::path::PathBuf;
26use std::str::FromStr;
27#[cfg(msim)]
28use std::sync::atomic::Ordering;
29use std::sync::{Arc, OnceLock, Weak};
30use std::time::Duration;
31use sui_core::admission_queue::{
32 AdmissionQueueContext, AdmissionQueueManager, AdmissionQueueMetrics,
33};
34use sui_core::authority::ExecutionEnv;
35use sui_core::authority::authority_store_tables::AuthorityPerpetualTablesOptions;
36use sui_core::authority::backpressure::BackpressureManager;
37use sui_core::authority::epoch_start_configuration::EpochFlag;
38use sui_core::authority::execution_time_estimator::ExecutionTimeObserver;
39use sui_core::consensus_adapter::ConsensusClient;
40use sui_core::consensus_manager::UpdatableConsensusClient;
41use sui_core::consensus_transaction_pool::TransactionPoolContext;
42use sui_core::epoch::randomness::RandomnessManager;
43use sui_core::execution_cache::build_execution_cache;
44use sui_core::randomness_round_receiver::{RandomnessRoundReceiver, RandomnessRoundReceiverHandle};
45use sui_network::endpoint_manager::{AddressSource, EndpointId};
46use sui_network::validator::server::SUI_TLS_SERVER_NAME;
47use sui_types::full_checkpoint_content::{Checkpoint, LocallyBuiltCheckpoint};
48use sui_types::node_role::NodeRole;
49
50use sui_core::global_state_hasher::GlobalStateHashMetrics;
51use sui_core::storage::RestReadStore;
52use sui_network::randomness;
53use sui_rpc_api::ServerVersion;
54use sui_rpc_api::subscription::SubscriptionService;
55use sui_types::base_types::ConciseableName;
56use sui_types::crypto::RandomnessRound;
57use sui_types::digests::{
58 ChainIdentifier, CheckpointDigest, TransactionDigest, TransactionEffectsDigest,
59};
60use sui_types::messages_consensus::AuthorityCapabilitiesV2;
61use sui_types::sui_system_state::SuiSystemState;
62use tap::tap::TapFallible;
63use tokio::sync::{Mutex, broadcast, mpsc};
64use tokio::task::JoinHandle;
65use tower::ServiceBuilder;
66use tracing::{Instrument, error_span, info};
67use tracing::{debug, error, warn};
68
69macro_rules! jwk_log {
73 ($($arg:tt)+) => {
74 if in_test_configuration() {
75 debug!($($arg)+);
76 } else {
77 info!($($arg)+);
78 }
79 };
80}
81
82use fastcrypto_zkp::bn254::zk_login::JWK;
83pub use handle::SuiNodeHandle;
84use mysten_metrics::{RegistryService, spawn_monitored_task};
85use mysten_service::server_timing::server_timing_middleware;
86use sui_config::node::{DBCheckpointConfig, RunWithRange};
87use sui_config::node::{ForkCrashBehavior, ForkRecoveryConfig};
88use sui_config::transaction_deny_config::TransactionDenyRules;
89use sui_config::{ConsensusConfig, NodeConfig};
90use sui_core::authority::authority_per_epoch_store::AuthorityPerEpochStore;
91use sui_core::authority::authority_store_tables::AuthorityPerpetualTables;
92use sui_core::authority::epoch_start_configuration::EpochStartConfigTrait;
93use sui_core::authority::epoch_start_configuration::EpochStartConfiguration;
94use sui_core::authority::submitted_transaction_cache::SubmittedTransactionCacheMetrics;
95use sui_core::authority_aggregator::AuthorityAggregator;
96use sui_core::authority_server::{UserSubmissionPath, ValidatorService, ValidatorServiceMetrics};
97use sui_core::checkpoints::checkpoint_executor::metrics::CheckpointExecutorMetrics;
98use sui_core::checkpoints::checkpoint_executor::{CheckpointExecutor, StopReason};
99use sui_core::checkpoints::{
100 CheckpointMetrics, CheckpointOutput, CheckpointService, CheckpointStore,
101 LocallyBuiltCheckpointPublisher, LogCheckpointOutput, SendCheckpointToStateSync,
102 SubmitCheckpointToConsensus,
103};
104use sui_core::consensus_adapter::{ConsensusAdapter, ConsensusAdapterMetrics};
105use sui_core::consensus_manager::ConsensusManager;
106use sui_core::consensus_throughput_calculator::ConsensusThroughputCalculator;
107use sui_core::consensus_validator::{SuiTxValidator, SuiTxValidatorMetrics};
108use sui_core::db_checkpoint_handler::DBCheckpointHandler;
109use sui_core::epoch::committee_store::CommitteeStore;
110use sui_core::epoch::consensus_store_pruner::ConsensusStorePruner;
111use sui_core::epoch::epoch_metrics::EpochMetrics;
112use sui_core::epoch::reconfiguration::ReconfigurationInitiator;
113use sui_core::global_state_hasher::GlobalStateHasher;
114use sui_core::module_cache_metrics::ResolverMetrics;
115use sui_core::overload_monitor::overload_monitor;
116use sui_core::rpc_store_embed::EmbeddedRpcStore;
117use sui_core::signature_verifier::SignatureVerifierMetrics;
118use sui_core::storage::RocksDbStore;
119use sui_core::storage::RpcStoreReadStore;
120use sui_core::transaction_orchestrator::TransactionOrchestrator;
121use sui_core::{
122 authority::{AuthorityState, AuthorityStore},
123 authority_client::NetworkAuthorityClient,
124};
125use sui_macros::fail_point;
126use sui_macros::{fail_point_arg, fail_point_async, replay_log};
127use sui_network::api::ValidatorServer;
128use sui_network::discovery;
129use sui_network::endpoint_manager::EndpointManager;
130use sui_network::state_sync;
131use sui_network::validator::server::ServerBuilder;
132use sui_protocol_config::{ProtocolConfig, ProtocolVersion};
133use sui_snapshot::uploader::StateSnapshotUploader;
134use sui_types::base_types::{AuthorityName, EpochId};
135use sui_types::committee::Committee;
136use sui_types::crypto::KeypairTraits;
137use sui_types::error::{SuiError, SuiResult};
138use sui_types::messages_consensus::{ConsensusTransaction, check_total_jwk_size};
139use sui_types::storage::RpcStateReader;
140use sui_types::sui_system_state::SuiSystemStateTrait;
141use sui_types::sui_system_state::epoch_start_sui_system_state::EpochStartSystemState;
142use sui_types::sui_system_state::epoch_start_sui_system_state::EpochStartSystemStateTrait;
143use sui_types::supported_protocol_versions::SupportedProtocolVersions;
144use typed_store::DBMetrics;
145use typed_store::rocks::default_db_options;
146
147use crate::metrics::{GrpcMetrics, SuiNodeMetrics};
148
149pub mod address_prober;
150pub mod admin;
151pub mod db_shell;
152mod handle;
153pub mod metrics;
154
155pub struct ValidatorComponents {
156 validator_server_handle: Option<ValidatorGrpcServer>,
157 validator_overload_monitor_handle: Option<JoinHandle<()>>,
158 consensus_manager: Arc<ConsensusManager>,
159 consensus_store_pruner: ConsensusStorePruner,
160 consensus_adapter: Arc<ConsensusAdapter>,
161 checkpoint_metrics: Arc<CheckpointMetrics>,
162 sui_tx_validator_metrics: Arc<SuiTxValidatorMetrics>,
163 admission_queue: Option<AdmissionQueueContext>,
164 transaction_pool_context: Option<Arc<TransactionPoolContext>>,
165}
166
167pub struct P2pComponents {
168 p2p_network: Network,
169 known_peers: HashMap<PeerId, String>,
170 discovery_handle: discovery::Handle,
171 state_sync_handle: state_sync::Handle,
172 randomness_handle: randomness::Handle,
173 endpoint_manager: EndpointManager,
174}
175
176#[cfg(msim)]
177mod simulator {
178 use std::sync::Mutex;
179 use std::sync::atomic::AtomicBool;
180 use sui_types::error::SuiErrorKind;
181
182 use super::*;
183 pub(super) struct SimState {
184 pub sim_node: sui_simulator::runtime::NodeHandle,
185 pub sim_safe_mode_expected: AtomicBool,
186 _leak_detector: sui_simulator::NodeLeakDetector,
187 }
188
189 impl Default for SimState {
190 fn default() -> Self {
191 Self {
192 sim_node: sui_simulator::runtime::NodeHandle::current(),
193 sim_safe_mode_expected: AtomicBool::new(false),
194 _leak_detector: sui_simulator::NodeLeakDetector::new(),
195 }
196 }
197 }
198
199 type JwkInjector = dyn Fn(AuthorityName, &OIDCProvider) -> SuiResult<Vec<(JwkId, JWK)>>
200 + Send
201 + Sync
202 + 'static;
203
204 fn default_fetch_jwks(
205 _authority: AuthorityName,
206 _provider: &OIDCProvider,
207 ) -> SuiResult<Vec<(JwkId, JWK)>> {
208 use fastcrypto_zkp::bn254::zk_login::parse_jwks;
209 parse_jwks(
211 sui_types::zk_login_util::DEFAULT_JWK_BYTES,
212 &OIDCProvider::Twitch,
213 true,
214 )
215 .map_err(|_| SuiErrorKind::JWKRetrievalError.into())
216 }
217
218 static JWK_INJECTOR: Mutex<Option<Arc<JwkInjector>>> = Mutex::new(None);
219
220 pub(super) fn get_jwk_injector() -> Arc<JwkInjector> {
221 JWK_INJECTOR
222 .lock()
223 .unwrap()
224 .clone()
225 .unwrap_or_else(|| Arc::new(default_fetch_jwks))
226 }
227
228 pub fn set_jwk_injector(injector: Arc<JwkInjector>) {
229 *JWK_INJECTOR.lock().unwrap() = Some(injector);
230 }
231}
232
233#[cfg(msim)]
234pub use simulator::set_jwk_injector;
235#[cfg(msim)]
236use simulator::*;
237use sui_core::authority::authority_store_pruner::PrunerWatermarks;
238use sui_core::{
239 consensus_handler::ConsensusHandlerInitializer, safe_client::SafeClientMetricsBase,
240};
241
242const DEFAULT_GRPC_CONNECT_TIMEOUT: Duration = Duration::from_secs(60);
243const VALIDATOR_GRPC_SERVER_SHUTDOWN_TIMEOUT: Duration = Duration::from_secs(30);
244
245fn epoch_store_release_grace_period() -> Duration {
250 if cfg!(msim) {
251 Duration::from_secs(15)
252 } else {
253 Duration::from_secs(60)
254 }
255}
256
257pub struct SuiNode {
258 config: NodeConfig,
259 validator_components: Mutex<Option<ValidatorComponents>>,
260
261 #[allow(unused)]
263 http_servers: HttpServers,
264
265 state: Arc<AuthorityState>,
266 transaction_orchestrator: Option<Arc<TransactionOrchestrator<NetworkAuthorityClient>>>,
267 registry_service: RegistryService,
268 metrics: Arc<SuiNodeMetrics>,
269 checkpoint_metrics: Arc<CheckpointMetrics>,
270
271 _discovery: discovery::Handle,
272 _connection_monitor_handle: mysten_network::anemo_connection_monitor::ConnectionMonitorHandle,
273 state_sync_handle: state_sync::Handle,
274 randomness_handle: randomness::Handle,
275 checkpoint_store: Arc<CheckpointStore>,
276 global_state_hasher: Mutex<Option<Arc<GlobalStateHasher>>>,
277
278 end_of_epoch_channel: broadcast::Sender<SuiSystemState>,
280
281 endpoint_manager: EndpointManager,
283
284 address_prober: Option<address_prober::Handle>,
286
287 backpressure_manager: Arc<BackpressureManager>,
288
289 _db_checkpoint_handle: Option<tokio::sync::broadcast::Sender<()>>,
290
291 #[cfg(msim)]
292 sim_state: SimState,
293
294 _state_snapshot_uploader_handle: Option<broadcast::Sender<()>>,
295 shutdown_channel_tx: broadcast::Sender<Option<RunWithRange>>,
297
298 randomness_receiver_handle: Arc<RandomnessRoundReceiverHandle>,
300
301 transaction_pool_context: Option<Arc<TransactionPoolContext>>,
304
305 consensus_adapter_metrics: OnceLock<ConsensusAdapterMetrics>,
306
307 auth_agg: Arc<ArcSwap<AuthorityAggregator<NetworkAuthorityClient>>>,
312
313 subscription_service_checkpoint_sender: Option<tokio::sync::broadcast::Sender<Arc<Checkpoint>>>,
314
315 locally_built_checkpoint_publisher: Option<LocallyBuiltCheckpointPublisher>,
319
320 embedded_rpc_store: Option<EmbeddedRpcStore>,
325}
326
327impl fmt::Debug for SuiNode {
328 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
329 f.debug_struct("SuiNode")
330 .field("name", &self.state.name.concise())
331 .finish()
332 }
333}
334
335static MAX_JWK_KEYS_PER_FETCH: usize = 100;
336
337impl SuiNode {
338 pub async fn start(
339 config: NodeConfig,
340 registry_service: RegistryService,
341 ) -> Result<Arc<SuiNode>> {
342 Self::start_async(
343 config,
344 registry_service,
345 ServerVersion::new("sui-node", "unknown"),
346 )
347 .await
348 }
349
350 fn start_jwk_updater(
351 config: &NodeConfig,
352 metrics: Arc<SuiNodeMetrics>,
353 authority: AuthorityName,
354 epoch_store: Arc<AuthorityPerEpochStore>,
355 consensus_adapter: Arc<ConsensusAdapter>,
356 ) {
357 let epoch = epoch_store.epoch();
358
359 let supported_providers = config
360 .zklogin_oauth_providers
361 .get(&epoch_store.get_chain_identifier().chain())
362 .unwrap_or(&BTreeSet::new())
363 .iter()
364 .map(|s| OIDCProvider::from_str(s).expect("Invalid provider string"))
365 .collect::<Vec<_>>();
366
367 let fetch_interval = Duration::from_secs(config.jwk_fetch_interval_seconds);
368
369 info!(
370 ?fetch_interval,
371 "Starting JWK updater tasks with supported providers: {:?}", supported_providers
372 );
373
374 fn validate_jwk(
375 metrics: &Arc<SuiNodeMetrics>,
376 provider: &OIDCProvider,
377 id: &JwkId,
378 jwk: &JWK,
379 ) -> bool {
380 let Ok(iss_provider) = OIDCProvider::from_iss(&id.iss) else {
381 warn!(
382 "JWK iss {:?} (retrieved from {:?}) is not a valid provider",
383 id.iss, provider
384 );
385 metrics
386 .invalid_jwks
387 .with_label_values(&[&provider.to_string()])
388 .inc();
389 return false;
390 };
391
392 if iss_provider != *provider {
393 warn!(
394 "JWK iss {:?} (retrieved from {:?}) does not match provider {:?}",
395 id.iss, provider, iss_provider
396 );
397 metrics
398 .invalid_jwks
399 .with_label_values(&[&provider.to_string()])
400 .inc();
401 return false;
402 }
403
404 if !check_total_jwk_size(id, jwk) {
405 warn!("JWK {:?} (retrieved from {:?}) is too large", id, provider);
406 metrics
407 .invalid_jwks
408 .with_label_values(&[&provider.to_string()])
409 .inc();
410 return false;
411 }
412
413 true
414 }
415
416 for p in supported_providers.into_iter() {
425 let provider_str = p.to_string();
426 let epoch_store = epoch_store.clone();
427 let consensus_adapter = consensus_adapter.clone();
428 let metrics = metrics.clone();
429 spawn_monitored_task!(epoch_store.clone().within_alive_epoch(
430 async move {
431 let mut seen = HashSet::new();
434 loop {
435 jwk_log!("fetching JWK for provider {:?}", p);
436 metrics.jwk_requests.with_label_values(&[&provider_str]).inc();
437 match Self::fetch_jwks(authority, &p).await {
438 Err(e) => {
439 metrics.jwk_request_errors.with_label_values(&[&provider_str]).inc();
440 warn!("Error when fetching JWK for provider {:?} {:?}", p, e);
441 tokio::time::sleep(Duration::from_secs(30)).await;
443 continue;
444 }
445 Ok(mut keys) => {
446 metrics.total_jwks
447 .with_label_values(&[&provider_str])
448 .inc_by(keys.len() as u64);
449
450 keys.retain(|(id, jwk)| {
451 validate_jwk(&metrics, &p, id, jwk) &&
452 !epoch_store.jwk_active_in_current_epoch(id, jwk) &&
453 seen.insert((id.clone(), jwk.clone()))
454 });
455
456 metrics.unique_jwks
457 .with_label_values(&[&provider_str])
458 .inc_by(keys.len() as u64);
459
460 if keys.len() > MAX_JWK_KEYS_PER_FETCH {
463 warn!("Provider {:?} sent too many JWKs, only the first {} will be used", p, MAX_JWK_KEYS_PER_FETCH);
464 keys.truncate(MAX_JWK_KEYS_PER_FETCH);
465 }
466
467 for (id, jwk) in keys.into_iter() {
468 jwk_log!("Submitting JWK to consensus: {:?}", id);
469
470 let txn = ConsensusTransaction::new_jwk_fetched(authority, id, jwk);
471 consensus_adapter.submit(txn, None, &epoch_store, None, None)
472 .tap_err(|e| warn!("Error when submitting JWKs to consensus {:?}", e))
473 .ok();
474 }
475 }
476 }
477 tokio::time::sleep(fetch_interval).await;
478 }
479 }
480 .instrument(error_span!("jwk_updater_task", epoch)),
481 ));
482 }
483 }
484
485 pub fn start_async(
488 config: NodeConfig,
489 registry_service: RegistryService,
490 server_version: ServerVersion,
491 ) -> BoxFuture<'static, Result<Arc<SuiNode>>> {
492 Self::start_async_impl(config, registry_service, server_version).boxed()
493 }
494
495 async fn start_async_impl(
496 config: NodeConfig,
497 registry_service: RegistryService,
498 server_version: ServerVersion,
499 ) -> Result<Arc<SuiNode>> {
500 if let Some(prober_config) = &config.address_prober {
502 prober_config.validate()?;
503 }
504
505 let mut config = config.clone();
506 if config.supported_protocol_versions.is_none() {
507 info!(
508 "populating config.supported_protocol_versions with default {:?}",
509 SupportedProtocolVersions::SYSTEM_DEFAULT
510 );
511 config.supported_protocol_versions = Some(SupportedProtocolVersions::SYSTEM_DEFAULT);
512 }
513
514 let run_with_range = config.run_with_range;
515 let prometheus_registry = registry_service.default_registry();
516 let node_role = config.intended_node_role();
517
518 info!(node =? config.protocol_public_key(),
519 "Initializing sui-node listening on {} with role {:?}", config.network_address, node_role
520 );
521
522 DBMetrics::init(registry_service.clone());
524
525 fastcrypto::bulletproofs::initialize_generators();
528
529 typed_store::init_write_sync(config.enable_db_sync_to_disk);
531
532 mysten_metrics::init_metrics(&prometheus_registry);
534 #[cfg(not(msim))]
536 mysten_metrics::thread_stall_monitor::start_thread_stall_monitor();
537
538 let genesis = config.genesis()?.clone();
539
540 let secret = Arc::pin(config.protocol_key_pair().copy());
541 let genesis_committee = genesis.committee();
542 let committee_store = Arc::new(CommitteeStore::new(
543 config.db_path().join("epochs"),
544 &genesis_committee,
545 None,
546 ));
547
548 let pruner_watermarks = Arc::new(PrunerWatermarks::default());
549 let checkpoint_store = CheckpointStore::new(
550 &config.db_path().join("checkpoints"),
551 pruner_watermarks.clone(),
552 );
553 let checkpoint_metrics = CheckpointMetrics::new(®istry_service.default_registry());
554
555 #[allow(unused_mut)]
556 let mut build_version = server_version.version.to_string();
557 fail_point_arg!("override_binary_version", |version: std::sync::Arc<
558 std::sync::Mutex<String>,
559 >| {
560 #[cfg(msim)]
561 {
562 build_version = version.lock().unwrap().clone();
563 }
564 });
565 checkpoint_store.set_binary_version(&build_version);
568
569 if node_role.runs_consensus() {
570 Self::check_and_recover_forks(
571 &checkpoint_store,
572 &checkpoint_metrics,
573 config.fork_recovery.as_ref(),
574 &build_version,
575 )
576 .await?;
577 }
578
579 let enable_write_stall = config
581 .enable_db_write_stall
582 .unwrap_or(node_role.runs_consensus());
583 let enable_objects_compactor = AuthorityPerpetualTablesOptions::objects_compactor_enabled(
587 node_role.is_validator(),
588 config.authority_store_pruning_config.num_epochs_to_retain,
589 );
590 let enable_rpc_indexing =
591 node_role.is_fullnode() && config.rpc().is_some_and(|rpc| rpc.enable_indexing());
592 anyhow::ensure!(
595 !(enable_objects_compactor && enable_rpc_indexing),
596 "authority-store-pruning-config.num-epochs-to-retain = 0 attaches the tidehunter \
597 objects compactor, which drops non-latest object versions that rpc indexes \
598 (rpc.enable-indexing = true) depend on. Set num-epochs-to-retain > 0 on a full node \
599 that serves rpc indexes, or set rpc.enable-indexing = false."
600 );
601 let perpetual_tables_options = AuthorityPerpetualTablesOptions {
602 enable_write_stall,
603 enable_objects_compactor,
604 };
605 let perpetual_tables = Arc::new(AuthorityPerpetualTables::open(
606 &config.db_store_path(),
607 Some(perpetual_tables_options),
608 Some(pruner_watermarks.epoch_id.clone()),
609 ));
610 let is_genesis = perpetual_tables
611 .database_is_empty()
612 .expect("Database read should not fail at init.");
613
614 let backpressure_manager =
615 BackpressureManager::new_from_checkpoint_store(&checkpoint_store);
616
617 let store =
618 AuthorityStore::open(perpetual_tables, &genesis, &config, &prometheus_registry).await?;
619
620 let cur_epoch = store.get_recovery_epoch_at_restart()?;
621 let committee = committee_store
622 .get_committee(&cur_epoch)?
623 .expect("Committee of the current epoch must exist");
624 let epoch_start_configuration = store
625 .get_epoch_start_configuration()?
626 .expect("EpochStartConfiguration of the current epoch must exist");
627 let cache_metrics = Arc::new(ResolverMetrics::new(&prometheus_registry));
628 let signature_verifier_metrics = SignatureVerifierMetrics::new(&prometheus_registry);
629
630 let cache_traits = build_execution_cache(
631 &config.execution_cache,
632 &prometheus_registry,
633 &store,
634 backpressure_manager.clone(),
635 );
636
637 let auth_agg = {
638 let safe_client_metrics_base = SafeClientMetricsBase::new(&prometheus_registry);
639 Arc::new(ArcSwap::new(Arc::new(
640 AuthorityAggregator::new_from_epoch_start_state(
641 epoch_start_configuration.epoch_start_state(),
642 &committee_store,
643 safe_client_metrics_base,
644 ),
645 )))
646 };
647
648 let chain_id = ChainIdentifier::from(*genesis.checkpoint().digest());
649 let chain = match config.chain_override_for_testing {
650 Some(chain) => chain,
651 None => ChainIdentifier::from(*genesis.checkpoint().digest()).chain(),
652 };
653
654 let highest_executed_checkpoint = checkpoint_store
655 .get_highest_executed_checkpoint_seq_number()
656 .expect("checkpoint store read cannot fail")
657 .unwrap_or(0);
658
659 let previous_epoch_last_checkpoint = if cur_epoch == 0 {
660 0
661 } else {
662 checkpoint_store
663 .get_epoch_last_checkpoint_seq_number(cur_epoch - 1)
664 .expect("checkpoint store read cannot fail")
665 .unwrap_or(highest_executed_checkpoint)
666 };
667
668 let epoch_options = default_db_options().optimize_db_for_write_throughput(4, false);
669 let epoch_store = AuthorityPerEpochStore::new(
670 config.protocol_public_key(),
671 committee.clone(),
672 &config.db_store_path(),
673 Some(epoch_options.options),
674 EpochMetrics::new(®istry_service.default_registry()),
675 epoch_start_configuration,
676 cache_traits.backing_package_store.clone(),
677 cache_traits.object_store.clone(),
678 cache_metrics,
679 signature_verifier_metrics,
680 &config.expensive_safety_check_config,
681 &config,
682 (chain_id, chain),
683 highest_executed_checkpoint,
684 previous_epoch_last_checkpoint,
685 Arc::new(SubmittedTransactionCacheMetrics::new(
686 ®istry_service.default_registry(),
687 )),
688 config.fullnode_sync_mode,
689 )?;
690
691 info!("created epoch store");
692
693 replay_log!(
694 "Beginning replay run. Epoch: {:?}, Protocol config: {:?}",
695 epoch_store.epoch(),
696 epoch_store.protocol_config()
697 );
698
699 if is_genesis {
701 info!("checking SUI conservation at genesis");
702 cache_traits
707 .reconfig_api
708 .expensive_check_sui_conservation(&epoch_store)
709 .expect("SUI conservation check cannot fail at genesis");
710 }
711
712 let effective_buffer_stake = epoch_store.get_effective_buffer_stake_bps();
713 let default_buffer_stake = epoch_store
714 .protocol_config()
715 .buffer_stake_for_protocol_upgrade_bps();
716 if effective_buffer_stake != default_buffer_stake {
717 warn!(
718 ?effective_buffer_stake,
719 ?default_buffer_stake,
720 "buffer_stake_for_protocol_upgrade_bps is currently overridden"
721 );
722 }
723
724 checkpoint_store.insert_genesis_checkpoint(
725 genesis.checkpoint(),
726 genesis.checkpoint_contents().clone(),
727 &epoch_store,
728 );
729
730 info!("creating state sync store");
731 let state_sync_store = RocksDbStore::new(
732 cache_traits.clone(),
733 committee_store.clone(),
734 checkpoint_store.clone(),
735 );
736
737 if node_role.is_fullnode() {
738 remove_legacy_index_stores(&config.db_path());
742 }
743
744 let chain_identifier = epoch_store.get_chain_identifier();
745
746 let mut embedded_rpc_store = if enable_rpc_indexing {
752 info!("creating embedded rpc-store");
753 let ingestion_source = RocksDbStore::new(
756 cache_traits.clone(),
757 committee_store.clone(),
758 checkpoint_store.clone(),
759 );
760 let embedded_rpc_store = EmbeddedRpcStore::bootstrap(
761 &config,
762 &store,
763 &checkpoint_store,
764 ingestion_source,
765 chain_identifier,
766 &prometheus_registry,
767 )
768 .await?;
769 Some(embedded_rpc_store)
770 } else {
771 None
772 };
773
774 info!("creating archive reader");
775 let (randomness_tx, randomness_rx) = mpsc::channel(
777 config
778 .p2p_config
779 .randomness
780 .clone()
781 .unwrap_or_default()
782 .mailbox_capacity(),
783 );
784 let P2pComponents {
785 p2p_network,
786 known_peers,
787 discovery_handle,
788 state_sync_handle,
789 randomness_handle,
790 endpoint_manager,
791 } = Self::create_p2p_network(
792 &config,
793 state_sync_store.clone(),
794 chain_identifier,
795 randomness_tx,
796 &prometheus_registry,
797 )?;
798
799 for peer in &config.p2p_config.peer_address_overrides {
801 endpoint_manager
802 .update_endpoint(
803 EndpointId::P2p(peer.peer_id),
804 AddressSource::Config,
805 peer.addresses.clone(),
806 )
807 .expect("Updating peer address overrides should not fail");
808 }
809
810 update_peer_addresses(
812 &config,
813 &endpoint_manager,
814 epoch_store.epoch_start_state(),
815 None,
816 );
817
818 info!("start snapshot upload");
819 let state_snapshot_handle = Self::start_state_snapshot(
821 &config,
822 &prometheus_registry,
823 checkpoint_store.clone(),
824 chain_identifier,
825 )?;
826
827 info!("start db checkpoint");
829 let (db_checkpoint_config, db_checkpoint_handle) = Self::start_db_checkpoint(
830 &config,
831 &prometheus_registry,
832 state_snapshot_handle.is_some(),
833 )?;
834
835 if !epoch_store
836 .protocol_config()
837 .simplified_unwrap_then_delete()
838 {
839 config
841 .authority_store_pruning_config
842 .set_killswitch_tombstone_pruning(true);
843 }
844
845 let authority_name = config.protocol_public_key();
846
847 info!("create authority state");
848 let state = AuthorityState::new(
849 authority_name,
850 secret,
851 config.supported_protocol_versions.unwrap(),
852 store.clone(),
853 cache_traits.clone(),
854 epoch_store.clone(),
855 committee_store.clone(),
856 embedded_rpc_store.as_ref().map(|embedded| embedded.store()),
857 checkpoint_store.clone(),
858 &prometheus_registry,
859 &db_checkpoint_config,
860 config.clone(),
861 chain_identifier,
862 config.policy_config.clone(),
863 config.firewall_config.clone(),
864 pruner_watermarks,
865 )
866 .await;
867 if epoch_store.epoch() == 0 {
869 let txn = &genesis.transaction();
870 let span = error_span!("genesis_txn", tx_digest = ?txn.digest());
871 let transaction =
872 sui_types::executable_transaction::VerifiedExecutableTransaction::new_unchecked(
873 sui_types::executable_transaction::ExecutableTransaction::new_from_data_and_sig(
874 genesis.transaction().data().clone(),
875 sui_types::executable_transaction::CertificateProof::Checkpoint(0, 0),
876 ),
877 );
878 let _enter = span.enter();
879 state
880 .try_execute_immediately(&transaction, ExecutionEnv::new(), &epoch_store)
881 .unwrap();
882 }
883
884 let randomness_receiver_handle =
887 RandomnessRoundReceiver::spawn(state.clone(), randomness_rx);
888
889 let (end_of_epoch_channel, end_of_epoch_receiver) =
890 broadcast::channel(config.end_of_epoch_broadcast_channel_capacity);
891
892 let transaction_orchestrator = if node_role.is_fullnode() && run_with_range.is_none() {
893 Some(Arc::new(TransactionOrchestrator::new_with_auth_aggregator(
894 auth_agg.load_full(),
895 state.clone(),
896 end_of_epoch_receiver,
897 &config.db_path(),
898 &prometheus_registry,
899 &config,
900 )))
901 } else {
902 None
903 };
904
905 let (http_servers, subscription_service_checkpoint_sender, locally_built_checkpoint_sender) =
906 build_http_servers(
907 state.clone(),
908 state_sync_store,
909 &transaction_orchestrator.clone(),
910 &config,
911 &prometheus_registry,
912 server_version,
913 node_role,
914 embedded_rpc_store.as_ref(),
915 )
916 .await?;
917
918 let locally_built_checkpoint_publisher = match locally_built_checkpoint_sender {
919 Some(sender) => Some(LocallyBuiltCheckpointPublisher::spawn(
920 state.clone(),
921 checkpoint_store.get_highest_executed_checkpoint_seq_number()?,
922 sender,
923 )),
924 None => None,
925 };
926
927 if let Some(embedded) = embedded_rpc_store.as_mut() {
934 embedded.spawn_indexer(
935 subscription_service_checkpoint_sender.clone(),
936 prometheus_registry.clone(),
937 );
938 }
939
940 let global_state_hasher = Arc::new(GlobalStateHasher::new(
941 cache_traits.global_state_hash_store.clone(),
942 GlobalStateHashMetrics::new(&prometheus_registry),
943 ));
944
945 let network_connection_metrics = mysten_network::quinn_metrics::QuinnConnectionMetrics::new(
946 "sui",
947 ®istry_service.default_registry(),
948 );
949
950 let connection_monitor_handle =
951 mysten_network::anemo_connection_monitor::AnemoConnectionMonitor::spawn(
952 p2p_network.downgrade(),
953 Arc::new(network_connection_metrics),
954 known_peers,
955 );
956
957 let sui_node_metrics = Arc::new(SuiNodeMetrics::new(®istry_service.default_registry()));
958
959 sui_node_metrics
960 .binary_max_protocol_version
961 .set(ProtocolVersion::MAX.as_u64() as i64);
962 sui_node_metrics
963 .configured_max_protocol_version
964 .set(config.supported_protocol_versions.unwrap().max.as_u64() as i64);
965
966 let consensus_adapter_metrics = OnceLock::new();
967 let transaction_pool_context = config.consensus_transaction_pool.enabled.then(|| {
968 Arc::new(TransactionPoolContext::new(
969 Arc::new(AdmissionQueueMetrics::new(
970 ®istry_service.default_registry(),
971 )),
972 consensus_adapter_metrics
973 .get_or_init(|| {
974 ConsensusAdapterMetrics::new(®istry_service.default_registry())
975 })
976 .clone(),
977 state.get_cache_writer().clone(),
978 ))
979 });
980 let node_role = epoch_store.node_role();
981 if !node_role.is_validator()
982 && let Some(context) = &transaction_pool_context
983 {
984 context.set_unavailable(epoch_store.epoch());
985 }
986 let validator_components = if node_role.runs_consensus() {
987 let mut components = Self::construct_validator_components(
988 config.clone(),
989 state.clone(),
990 committee,
991 epoch_store.clone(),
992 checkpoint_store.clone(),
993 state_sync_handle.clone(),
994 randomness_handle.clone(),
995 Arc::downgrade(&global_state_hasher),
996 backpressure_manager.clone(),
997 ®istry_service,
998 transaction_pool_context.clone(),
999 &consensus_adapter_metrics,
1000 sui_node_metrics.clone(),
1001 checkpoint_metrics.clone(),
1002 node_role,
1003 randomness_receiver_handle.clone(),
1004 locally_built_checkpoint_publisher.clone(),
1005 )
1006 .await?;
1007
1008 if node_role.is_validator() {
1009 components
1010 .consensus_adapter
1011 .recover_end_of_publish(&epoch_store);
1012
1013 components.validator_server_handle = Some(
1015 components
1016 .validator_server_handle
1017 .take()
1018 .unwrap()
1019 .start()
1020 .await,
1021 );
1022
1023 endpoint_manager
1025 .set_consensus_address_updater(components.consensus_manager.clone());
1026 } else {
1027 info!("Starting node as Observer — connecting to configured peers");
1028 }
1029
1030 Some(components)
1031 } else {
1032 None
1033 };
1034
1035 let address_prober = if Self::address_prober_enabled(&config) {
1036 let handle = address_prober::Builder::new()
1037 .config(config.address_prober.clone().unwrap_or_default())
1038 .with_metrics(&prometheus_registry)
1039 .build()
1040 .start(
1041 p2p_network.clone(),
1042 discovery_handle.sender(),
1043 consensus_config::NetworkKeyPair::new(config.network_key_pair().copy()),
1044 );
1045 if node_role.is_validator()
1047 && let Some(components) = &validator_components
1048 {
1049 handle.update_epoch(
1050 epoch_store.epoch(),
1051 epoch_store.epoch_start_state().get_consensus_committee(),
1052 components.consensus_manager.clone(),
1053 );
1054 }
1055 Some(handle)
1056 } else {
1057 None
1058 };
1059
1060 let (shutdown_channel, _) = broadcast::channel::<Option<RunWithRange>>(1);
1062
1063 let node = Self {
1064 config,
1065 validator_components: Mutex::new(validator_components),
1066 http_servers,
1067 state,
1068 transaction_orchestrator,
1069 registry_service,
1070 metrics: sui_node_metrics,
1071 checkpoint_metrics,
1072
1073 _discovery: discovery_handle,
1074 _connection_monitor_handle: connection_monitor_handle,
1075 state_sync_handle,
1076 randomness_handle,
1077 checkpoint_store,
1078 global_state_hasher: Mutex::new(Some(global_state_hasher)),
1079 end_of_epoch_channel,
1080 endpoint_manager,
1081 backpressure_manager,
1082 address_prober,
1083
1084 _db_checkpoint_handle: db_checkpoint_handle,
1085
1086 #[cfg(msim)]
1087 sim_state: Default::default(),
1088
1089 _state_snapshot_uploader_handle: state_snapshot_handle,
1090 shutdown_channel_tx: shutdown_channel,
1091 randomness_receiver_handle,
1092 transaction_pool_context,
1093 consensus_adapter_metrics,
1094
1095 auth_agg,
1096 subscription_service_checkpoint_sender,
1097 locally_built_checkpoint_publisher,
1098 embedded_rpc_store,
1099 };
1100
1101 info!("SuiNode started!");
1102 let node = Arc::new(node);
1103 let node_copy = node.clone();
1104 spawn_monitored_task!(async move {
1105 let result = Self::monitor_reconfiguration(node_copy, epoch_store).await;
1106 if let Err(error) = result {
1107 warn!("Reconfiguration finished with error {:?}", error);
1108 }
1109 });
1110
1111 Ok(node)
1112 }
1113
1114 pub fn subscribe_to_epoch_change(&self) -> broadcast::Receiver<SuiSystemState> {
1115 self.end_of_epoch_channel.subscribe()
1116 }
1117
1118 pub fn subscribe_to_shutdown_channel(&self) -> broadcast::Receiver<Option<RunWithRange>> {
1119 self.shutdown_channel_tx.subscribe()
1120 }
1121
1122 pub fn current_epoch_for_testing(&self) -> EpochId {
1123 self.state.current_epoch_for_testing()
1124 }
1125
1126 pub fn db_checkpoint_path(&self) -> PathBuf {
1127 self.config.db_checkpoint_path()
1128 }
1129
1130 pub async fn close_epoch(&self, epoch_store: &Arc<AuthorityPerEpochStore>) -> SuiResult {
1132 info!("close_epoch (current epoch = {})", epoch_store.epoch());
1133 self.validator_components
1134 .lock()
1135 .await
1136 .as_ref()
1137 .ok_or_else(|| SuiError::from("Node is not a validator"))?
1138 .consensus_adapter
1139 .close_epoch(epoch_store);
1140 Ok(())
1141 }
1142
1143 pub fn clear_override_protocol_upgrade_buffer_stake(&self, epoch: EpochId) -> SuiResult {
1144 self.state
1145 .clear_override_protocol_upgrade_buffer_stake(epoch)
1146 }
1147
1148 pub fn set_override_protocol_upgrade_buffer_stake(
1149 &self,
1150 epoch: EpochId,
1151 buffer_stake_bps: u64,
1152 ) -> SuiResult {
1153 self.state
1154 .set_override_protocol_upgrade_buffer_stake(epoch, buffer_stake_bps)
1155 }
1156
1157 pub async fn close_epoch_for_testing(&self) -> SuiResult {
1160 let epoch_store = self.state.epoch_store_for_testing();
1161 self.close_epoch(&epoch_store).await
1162 }
1163
1164 fn start_state_snapshot(
1165 config: &NodeConfig,
1166 prometheus_registry: &Registry,
1167 checkpoint_store: Arc<CheckpointStore>,
1168 chain_identifier: ChainIdentifier,
1169 ) -> Result<Option<tokio::sync::broadcast::Sender<()>>> {
1170 if let Some(remote_store_config) = &config.state_snapshot_write_config.object_store_config {
1171 let snapshot_uploader = StateSnapshotUploader::new(
1172 &config.db_checkpoint_path(),
1173 &config.snapshot_path(),
1174 remote_store_config.clone(),
1175 60,
1176 prometheus_registry,
1177 checkpoint_store,
1178 chain_identifier,
1179 config.state_snapshot_write_config.archive_interval_epochs,
1180 )?;
1181 Ok(Some(snapshot_uploader.start()))
1182 } else {
1183 Ok(None)
1184 }
1185 }
1186
1187 fn start_db_checkpoint(
1188 config: &NodeConfig,
1189 prometheus_registry: &Registry,
1190 state_snapshot_enabled: bool,
1191 ) -> Result<(
1192 DBCheckpointConfig,
1193 Option<tokio::sync::broadcast::Sender<()>>,
1194 )> {
1195 let checkpoint_path = Some(
1196 config
1197 .db_checkpoint_config
1198 .checkpoint_path
1199 .clone()
1200 .unwrap_or_else(|| config.db_checkpoint_path()),
1201 );
1202 let db_checkpoint_config = if config.db_checkpoint_config.checkpoint_path.is_none() {
1203 DBCheckpointConfig {
1204 checkpoint_path,
1205 perform_db_checkpoints_at_epoch_end: if state_snapshot_enabled {
1206 true
1207 } else {
1208 config
1209 .db_checkpoint_config
1210 .perform_db_checkpoints_at_epoch_end
1211 },
1212 ..config.db_checkpoint_config.clone()
1213 }
1214 } else {
1215 config.db_checkpoint_config.clone()
1216 };
1217
1218 match (
1219 db_checkpoint_config.object_store_config.as_ref(),
1220 state_snapshot_enabled,
1221 ) {
1222 (None, false) => Ok((db_checkpoint_config, None)),
1227 (_, _) => {
1228 let handler = DBCheckpointHandler::new(
1229 &db_checkpoint_config.checkpoint_path.clone().unwrap(),
1230 db_checkpoint_config.object_store_config.as_ref(),
1231 60,
1232 db_checkpoint_config
1233 .prune_and_compact_before_upload
1234 .unwrap_or(true),
1235 config.authority_store_pruning_config.clone(),
1236 prometheus_registry,
1237 state_snapshot_enabled,
1238 )?;
1239 Ok((
1240 db_checkpoint_config,
1241 Some(DBCheckpointHandler::start(handler)),
1242 ))
1243 }
1244 }
1245 }
1246
1247 fn create_p2p_network(
1248 config: &NodeConfig,
1249 state_sync_store: RocksDbStore,
1250 chain_identifier: ChainIdentifier,
1251 randomness_tx: mpsc::Sender<(EpochId, RandomnessRound, Vec<u8>)>,
1252 prometheus_registry: &Registry,
1253 ) -> Result<P2pComponents> {
1254 let mut p2p_config = config.p2p_config.clone();
1255 {
1256 let disc = p2p_config.discovery.get_or_insert_with(Default::default);
1257 if disc.peer_addr_store_path.is_none() {
1258 disc.peer_addr_store_path =
1259 Some(config.db_path().join("discovery_peer_cache.yaml"));
1260 }
1261 }
1262 let mut discovery_builder = discovery::Builder::new().config(p2p_config.clone());
1263 if let Some(consensus_config) = &config.consensus_config {
1264 let effective_addr = consensus_config
1265 .external_address
1266 .as_ref()
1267 .or(consensus_config.listen_address.as_ref());
1268 if let Some(addr) = effective_addr {
1269 discovery_builder = discovery_builder.consensus_external_address(addr.clone());
1270 }
1271 }
1272 let (discovery, discovery_server, endpoint_manager) = discovery_builder.build();
1273 let discovery_sender = discovery.sender();
1274
1275 let (state_sync, state_sync_router) = state_sync::Builder::new()
1276 .config(config.p2p_config.state_sync.clone().unwrap_or_default())
1277 .store(state_sync_store)
1278 .archive_config(config.archive_reader_config())
1279 .discovery_sender(discovery_sender)
1280 .with_metrics(prometheus_registry)
1281 .build();
1282
1283 let discovery_config = config.p2p_config.discovery.clone().unwrap_or_default();
1284 let known_peers: HashMap<PeerId, String> = discovery_config
1285 .allowlisted_peers
1286 .clone()
1287 .into_iter()
1288 .map(|ap| (ap.peer_id, "allowlisted_peer".to_string()))
1289 .chain(config.p2p_config.seed_peers.iter().filter_map(|peer| {
1290 peer.peer_id
1291 .map(|peer_id| (peer_id, "seed_peer".to_string()))
1292 }))
1293 .collect();
1294
1295 let (randomness, randomness_router) =
1296 randomness::Builder::new(config.protocol_public_key(), randomness_tx)
1297 .config(config.p2p_config.randomness.clone().unwrap_or_default())
1298 .with_metrics(prometheus_registry)
1299 .build();
1300
1301 let p2p_network = {
1302 let routes = anemo::Router::new()
1303 .add_rpc_service(discovery_server)
1304 .merge(state_sync_router);
1305 let routes = routes.merge(randomness_router);
1306
1307 let inbound_network_metrics =
1308 mysten_network::metrics::NetworkMetrics::new("sui", "inbound", prometheus_registry);
1309 let outbound_network_metrics = mysten_network::metrics::NetworkMetrics::new(
1310 "sui",
1311 "outbound",
1312 prometheus_registry,
1313 );
1314
1315 let service = ServiceBuilder::new()
1316 .layer(
1317 TraceLayer::new_for_server_errors()
1318 .make_span_with(DefaultMakeSpan::new().level(tracing::Level::INFO))
1319 .on_failure(DefaultOnFailure::new().level(tracing::Level::WARN)),
1320 )
1321 .layer(CallbackLayer::new(
1322 mysten_network::metrics::MetricsMakeCallbackHandler::new(
1323 Arc::new(inbound_network_metrics),
1324 config.p2p_config.excessive_message_size(),
1325 ),
1326 ))
1327 .service(routes);
1328
1329 let outbound_layer = ServiceBuilder::new()
1330 .layer(
1331 TraceLayer::new_for_client_and_server_errors()
1332 .make_span_with(DefaultMakeSpan::new().level(tracing::Level::INFO))
1333 .on_failure(DefaultOnFailure::new().level(tracing::Level::WARN)),
1334 )
1335 .layer(CallbackLayer::new(
1336 mysten_network::metrics::MetricsMakeCallbackHandler::new(
1337 Arc::new(outbound_network_metrics),
1338 config.p2p_config.excessive_message_size(),
1339 ),
1340 ))
1341 .into_inner();
1342
1343 let mut anemo_config = config.p2p_config.anemo_config.clone().unwrap_or_default();
1344 anemo_config.max_request_frame_size = Some(1 << 20);
1347 anemo_config.max_response_frame_size = Some(128 << 20);
1350
1351 let mut quic_config = anemo_config.quic.unwrap_or_default();
1354 if quic_config.socket_send_buffer_size.is_none() {
1355 quic_config.socket_send_buffer_size = Some(20 << 20);
1356 }
1357 if quic_config.socket_receive_buffer_size.is_none() {
1358 quic_config.socket_receive_buffer_size = Some(20 << 20);
1359 }
1360 quic_config.allow_failed_socket_buffer_size_setting = true;
1361
1362 if quic_config.max_concurrent_bidi_streams.is_none() {
1365 quic_config.max_concurrent_bidi_streams = Some(500);
1366 }
1367 if quic_config.max_concurrent_uni_streams.is_none() {
1368 quic_config.max_concurrent_uni_streams = Some(500);
1369 }
1370 if quic_config.stream_receive_window.is_none() {
1371 quic_config.stream_receive_window = Some(100 << 20);
1372 }
1373 if quic_config.receive_window.is_none() {
1374 quic_config.receive_window = Some(200 << 20);
1375 }
1376 if quic_config.send_window.is_none() {
1377 quic_config.send_window = Some(200 << 20);
1378 }
1379 if quic_config.crypto_buffer_size.is_none() {
1380 quic_config.crypto_buffer_size = Some(1 << 20);
1381 }
1382 if quic_config.max_idle_timeout_ms.is_none() {
1383 quic_config.max_idle_timeout_ms = Some(10_000);
1384 }
1385 if quic_config.keep_alive_interval_ms.is_none() {
1386 quic_config.keep_alive_interval_ms = Some(5_000);
1387 }
1388 anemo_config.quic = Some(quic_config);
1389
1390 let server_name = format!("sui-{}", chain_identifier);
1391 let network = Network::bind(config.p2p_config.listen_address)
1392 .server_name(&server_name)
1393 .private_key(config.network_key_pair().copy().private().0.to_bytes())
1394 .config(anemo_config)
1395 .outbound_request_layer(outbound_layer)
1396 .start(service)?;
1397 info!(
1398 server_name = server_name,
1399 "P2p network started on {}",
1400 network.local_addr()
1401 );
1402
1403 network
1404 };
1405
1406 let discovery_handle =
1407 discovery.start(p2p_network.clone(), config.network_key_pair().copy());
1408 let state_sync_handle = state_sync.start(p2p_network.clone());
1409 let randomness_handle = randomness.start(p2p_network.clone());
1410
1411 Ok(P2pComponents {
1412 p2p_network,
1413 known_peers,
1414 discovery_handle,
1415 state_sync_handle,
1416 randomness_handle,
1417 endpoint_manager,
1418 })
1419 }
1420
1421 async fn construct_validator_components(
1422 config: NodeConfig,
1423 state: Arc<AuthorityState>,
1424 committee: Arc<Committee>,
1425 epoch_store: Arc<AuthorityPerEpochStore>,
1426 checkpoint_store: Arc<CheckpointStore>,
1427 state_sync_handle: state_sync::Handle,
1428 randomness_handle: randomness::Handle,
1429 global_state_hasher: Weak<GlobalStateHasher>,
1430 backpressure_manager: Arc<BackpressureManager>,
1431 registry_service: &RegistryService,
1432 transaction_pool_context: Option<Arc<TransactionPoolContext>>,
1433 consensus_adapter_metrics: &OnceLock<ConsensusAdapterMetrics>,
1434 sui_node_metrics: Arc<SuiNodeMetrics>,
1435 checkpoint_metrics: Arc<CheckpointMetrics>,
1436 node_role: NodeRole,
1437 randomness_receiver_handle: Arc<RandomnessRoundReceiverHandle>,
1438 locally_built_checkpoint_publisher: Option<LocallyBuiltCheckpointPublisher>,
1439 ) -> Result<ValidatorComponents> {
1440 let mut config_clone = config.clone();
1441 let consensus_config = config_clone
1442 .consensus_config
1443 .as_mut()
1444 .ok_or_else(|| anyhow!("Node is missing consensus config"))?;
1445
1446 let client = Arc::new(UpdatableConsensusClient::new());
1447 let inflight_slot_freed_notify = Arc::new(tokio::sync::Notify::new());
1448 let consensus_adapter = Arc::new(Self::construct_consensus_adapter(
1449 &committee,
1450 consensus_config,
1451 state.name,
1452 consensus_adapter_metrics
1453 .get_or_init(|| ConsensusAdapterMetrics::new(®istry_service.default_registry()))
1454 .clone(),
1455 client.clone(),
1456 checkpoint_store.clone(),
1457 inflight_slot_freed_notify.clone(),
1458 ));
1459
1460 let consensus_manager = Arc::new(ConsensusManager::new(
1461 &config,
1462 consensus_config,
1463 registry_service,
1464 client,
1465 transaction_pool_context.clone(),
1466 node_role,
1467 ));
1468
1469 let consensus_store_pruner = ConsensusStorePruner::new(
1471 consensus_manager.get_storage_base_path(),
1472 consensus_config.db_retention_epochs(),
1473 consensus_config.db_pruner_period(),
1474 ®istry_service.default_registry(),
1475 );
1476
1477 let sui_tx_validator_metrics =
1478 SuiTxValidatorMetrics::new(®istry_service.default_registry());
1479
1480 let (validator_server_handle, admission_queue) = if node_role.is_validator() {
1481 let (handle, queue) = Self::start_grpc_validator_service(
1482 &config,
1483 state.clone(),
1484 consensus_adapter.clone(),
1485 epoch_store.clone(),
1486 ®istry_service.default_registry(),
1487 inflight_slot_freed_notify,
1488 transaction_pool_context.clone(),
1489 )
1490 .await?;
1491 (Some(handle), queue)
1492 } else {
1493 (None, None)
1494 };
1495
1496 let validator_overload_monitor_handle = if node_role.is_validator()
1499 && config
1500 .authority_overload_config
1501 .max_load_shedding_percentage
1502 > 0
1503 {
1504 let authority_state = Arc::downgrade(&state);
1505 let overload_config = config.authority_overload_config.clone();
1506 fail_point!("starting_overload_monitor");
1507 Some(spawn_monitored_task!(overload_monitor(
1508 authority_state,
1509 overload_config,
1510 )))
1511 } else {
1512 None
1513 };
1514
1515 Self::start_epoch_specific_validator_components(
1516 &config,
1517 state.clone(),
1518 consensus_adapter,
1519 checkpoint_store,
1520 epoch_store,
1521 state_sync_handle,
1522 randomness_handle,
1523 randomness_receiver_handle,
1524 consensus_manager,
1525 consensus_store_pruner,
1526 global_state_hasher,
1527 backpressure_manager,
1528 validator_server_handle,
1529 validator_overload_monitor_handle,
1530 checkpoint_metrics,
1531 sui_node_metrics,
1532 sui_tx_validator_metrics,
1533 admission_queue,
1534 transaction_pool_context,
1535 node_role,
1536 locally_built_checkpoint_publisher,
1537 )
1538 .await
1539 }
1540
1541 fn address_prober_enabled(config: &NodeConfig) -> bool {
1542 let prober_enabled = config
1543 .address_prober
1544 .as_ref()
1545 .map(|c| c.enabled())
1546 .unwrap_or(true);
1547 let v3_enabled = config
1548 .p2p_config
1549 .discovery
1550 .as_ref()
1551 .is_some_and(|d| d.use_get_known_peers_v3());
1552 prober_enabled && v3_enabled
1553 }
1554
1555 fn update_address_prober_epoch(
1556 &self,
1557 epoch_store: &AuthorityPerEpochStore,
1558 consensus_manager: &Arc<ConsensusManager>,
1559 ) {
1560 if !epoch_store.is_validator() {
1561 return;
1562 }
1563 if let Some(handle) = &self.address_prober {
1564 handle.update_epoch(
1565 epoch_store.epoch(),
1566 epoch_store.epoch_start_state().get_consensus_committee(),
1567 consensus_manager.clone(),
1568 );
1569 }
1570 }
1571
1572 #[allow(clippy::too_many_arguments)]
1573 async fn start_epoch_specific_validator_components(
1574 config: &NodeConfig,
1575 state: Arc<AuthorityState>,
1576 consensus_adapter: Arc<ConsensusAdapter>,
1577 checkpoint_store: Arc<CheckpointStore>,
1578 epoch_store: Arc<AuthorityPerEpochStore>,
1579 state_sync_handle: state_sync::Handle,
1580 randomness_handle: randomness::Handle,
1581 randomness_receiver_handle: Arc<RandomnessRoundReceiverHandle>,
1582 consensus_manager: Arc<ConsensusManager>,
1583 consensus_store_pruner: ConsensusStorePruner,
1584 state_hasher: Weak<GlobalStateHasher>,
1585 backpressure_manager: Arc<BackpressureManager>,
1586 validator_server_handle: Option<ValidatorGrpcServer>,
1587 validator_overload_monitor_handle: Option<JoinHandle<()>>,
1588 checkpoint_metrics: Arc<CheckpointMetrics>,
1589 sui_node_metrics: Arc<SuiNodeMetrics>,
1590 sui_tx_validator_metrics: Arc<SuiTxValidatorMetrics>,
1591 admission_queue: Option<AdmissionQueueContext>,
1592 transaction_pool_context: Option<Arc<TransactionPoolContext>>,
1593 node_role: NodeRole,
1594 locally_built_checkpoint_publisher: Option<LocallyBuiltCheckpointPublisher>,
1595 ) -> Result<ValidatorComponents> {
1596 let checkpoint_service = Self::build_checkpoint_service(
1597 config,
1598 consensus_adapter.clone(),
1599 checkpoint_store.clone(),
1600 epoch_store.clone(),
1601 state.clone(),
1602 state_sync_handle,
1603 state_hasher,
1604 checkpoint_metrics.clone(),
1605 node_role,
1606 locally_built_checkpoint_publisher,
1607 );
1608
1609 randomness_receiver_handle.clear_public_key();
1612
1613 if node_role.runs_consensus() && epoch_store.randomness_state_enabled() {
1614 let authority_key_pair = if node_role.is_validator() {
1615 Some(config.protocol_key_pair())
1616 } else {
1617 None
1618 };
1619 let randomness_manager = RandomnessManager::try_new(
1620 Arc::downgrade(&epoch_store),
1621 Box::new(consensus_adapter.clone()),
1622 randomness_handle,
1623 authority_key_pair,
1624 randomness_receiver_handle.clone(),
1625 )
1626 .await;
1627 if let Some(randomness_manager) = randomness_manager {
1628 epoch_store
1629 .set_randomness_manager(randomness_manager)
1630 .await?;
1631 }
1632 }
1633
1634 if node_role.is_validator() {
1635 ExecutionTimeObserver::spawn(
1636 epoch_store.clone(),
1637 Box::new(consensus_adapter.clone()),
1638 config
1639 .execution_time_observer_config
1640 .clone()
1641 .unwrap_or_default(),
1642 );
1643 }
1644
1645 let throughput_calculator = Arc::new(ConsensusThroughputCalculator::new(
1646 None,
1647 state.metrics.clone(),
1648 ));
1649
1650 let consensus_handler_initializer = ConsensusHandlerInitializer::new(
1651 state.clone(),
1652 checkpoint_service.clone(),
1653 epoch_store.clone(),
1654 throughput_calculator,
1655 backpressure_manager,
1656 config.congestion_log.clone(),
1657 );
1658
1659 info!("Starting consensus manager asynchronously");
1660
1661 let replay_waiter = consensus_manager.replay_waiter();
1664
1665 tokio::spawn({
1667 let config = config.clone();
1668 let epoch_store = epoch_store.clone();
1669 let sui_tx_validator = SuiTxValidator::new(
1670 state.clone(),
1671 epoch_store.clone(),
1672 checkpoint_service.clone(),
1673 sui_tx_validator_metrics.clone(),
1674 );
1675 let consensus_manager = consensus_manager.clone();
1676 async move {
1677 consensus_manager
1678 .start(
1679 &config,
1680 epoch_store,
1681 consensus_handler_initializer,
1682 sui_tx_validator,
1683 Some(randomness_receiver_handle),
1684 )
1685 .await;
1686 }
1687 });
1688 info!("Spawning checkpoint service");
1689 let replay_waiter = if std::env::var("DISABLE_REPLAY_WAITER").is_ok() {
1690 None
1691 } else {
1692 Some(replay_waiter)
1693 };
1694 checkpoint_service
1695 .spawn(epoch_store.clone(), replay_waiter)
1696 .await;
1697
1698 if node_role.is_validator() && epoch_store.authenticator_state_enabled() {
1699 Self::start_jwk_updater(
1700 config,
1701 sui_node_metrics,
1702 state.name,
1703 epoch_store.clone(),
1704 consensus_adapter.clone(),
1705 );
1706 }
1707
1708 if let Some(ctx) = &admission_queue {
1709 ctx.rotate_for_epoch(epoch_store);
1710 }
1711
1712 Ok(ValidatorComponents {
1713 validator_server_handle,
1714 validator_overload_monitor_handle,
1715 consensus_manager,
1716 consensus_store_pruner,
1717 consensus_adapter,
1718 checkpoint_metrics,
1719 sui_tx_validator_metrics,
1720 admission_queue,
1721 transaction_pool_context,
1722 })
1723 }
1724
1725 fn build_checkpoint_service(
1726 config: &NodeConfig,
1727 consensus_adapter: Arc<ConsensusAdapter>,
1728 checkpoint_store: Arc<CheckpointStore>,
1729 epoch_store: Arc<AuthorityPerEpochStore>,
1730 state: Arc<AuthorityState>,
1731 state_sync_handle: state_sync::Handle,
1732 state_hasher: Weak<GlobalStateHasher>,
1733 checkpoint_metrics: Arc<CheckpointMetrics>,
1734 node_role: NodeRole,
1735 locally_built_checkpoint_publisher: Option<LocallyBuiltCheckpointPublisher>,
1736 ) -> Arc<CheckpointService> {
1737 let checkpoint_output: Box<dyn CheckpointOutput> = if node_role.is_validator() {
1738 Box::new(SubmitCheckpointToConsensus::new(
1739 consensus_adapter,
1740 state.secret.clone(),
1741 config.protocol_public_key(),
1742 checkpoint_metrics.clone(),
1743 ))
1744 } else {
1745 Box::new(LogCheckpointOutput::new(checkpoint_metrics.clone()))
1746 };
1747 let checkpoint_output = match locally_built_checkpoint_publisher {
1748 Some(publisher) => publisher.wrap_output(checkpoint_output),
1749 None => checkpoint_output,
1750 };
1751
1752 let certified_checkpoint_output = SendCheckpointToStateSync::new(state_sync_handle);
1753
1754 CheckpointService::build(
1755 state.clone(),
1756 checkpoint_store,
1757 epoch_store,
1758 state.get_transaction_cache_reader().clone(),
1759 state_hasher,
1760 checkpoint_output,
1761 Box::new(certified_checkpoint_output),
1762 checkpoint_metrics,
1763 )
1764 }
1765
1766 fn construct_consensus_adapter(
1767 committee: &Committee,
1768 consensus_config: &ConsensusConfig,
1769 authority: AuthorityName,
1770 ca_metrics: ConsensusAdapterMetrics,
1771 consensus_client: Arc<dyn ConsensusClient>,
1772 checkpoint_store: Arc<CheckpointStore>,
1773 inflight_slot_freed_notify: Arc<tokio::sync::Notify>,
1774 ) -> ConsensusAdapter {
1775 ConsensusAdapter::new(
1777 consensus_client,
1778 checkpoint_store,
1779 authority,
1780 consensus_config.max_pending_transactions(),
1781 consensus_config.max_pending_transactions() * 2 / committee.num_members(),
1782 ca_metrics,
1783 inflight_slot_freed_notify,
1784 )
1785 }
1786
1787 async fn start_grpc_validator_service(
1788 config: &NodeConfig,
1789 state: Arc<AuthorityState>,
1790 consensus_adapter: Arc<ConsensusAdapter>,
1791 epoch_store: Arc<AuthorityPerEpochStore>,
1792 prometheus_registry: &Registry,
1793 inflight_slot_freed_notify: Arc<tokio::sync::Notify>,
1794 transaction_pool_context: Option<Arc<TransactionPoolContext>>,
1795 ) -> Result<(ValidatorGrpcServer, Option<AdmissionQueueContext>)> {
1796 let overload_config = &config.authority_overload_config;
1797 let admission_queue =
1798 if transaction_pool_context.is_none() && overload_config.admission_queue_enabled {
1799 let manager = Arc::new(AdmissionQueueManager::new(
1800 consensus_adapter.clone(),
1801 Arc::new(AdmissionQueueMetrics::new(prometheus_registry)),
1802 overload_config.admission_queue_capacity_fraction,
1803 overload_config.admission_queue_failover_timeout,
1804 inflight_slot_freed_notify,
1805 ));
1806 Some(AdmissionQueueContext::spawn(manager, epoch_store))
1807 } else {
1808 None
1809 };
1810 let user_submission_path = if let Some(context) = transaction_pool_context {
1811 UserSubmissionPath::Pool(context)
1812 } else if let Some(context) = admission_queue.clone() {
1813 UserSubmissionPath::AdmissionQueue(context)
1814 } else {
1815 UserSubmissionPath::Direct
1816 };
1817 let validator_service = ValidatorService::new(
1818 state.clone(),
1819 consensus_adapter,
1820 Arc::new(ValidatorServiceMetrics::new(prometheus_registry)),
1821 config.policy_config.clone().map(|p| p.client_id_source),
1822 user_submission_path,
1823 );
1824
1825 let mut server_conf = mysten_network::config::Config::new();
1826 server_conf.connect_timeout = Some(DEFAULT_GRPC_CONNECT_TIMEOUT);
1827 server_conf.http2_keepalive_interval = Some(DEFAULT_GRPC_CONNECT_TIMEOUT);
1828 server_conf.http2_keepalive_timeout = Some(DEFAULT_GRPC_CONNECT_TIMEOUT);
1829 server_conf.global_concurrency_limit = config.grpc_concurrency_limit;
1830 server_conf.load_shed = config.grpc_load_shed;
1831 let mut server_builder =
1832 ServerBuilder::from_config(&server_conf, GrpcMetrics::new(prometheus_registry));
1833
1834 server_builder = server_builder.add_service(ValidatorServer::new(validator_service));
1835
1836 let tls_config = sui_tls::create_rustls_server_config(
1837 config.network_key_pair().copy().private(),
1838 SUI_TLS_SERVER_NAME.to_string(),
1839 );
1840
1841 let network_address = config.network_address().clone();
1842
1843 let server = ValidatorGrpcServer::new(async move {
1844 let server = server_builder
1845 .bind(&network_address, Some(tls_config))
1846 .await
1847 .unwrap_or_else(|err| panic!("Failed to bind to {network_address}: {err}"));
1848 info!("Listening to traffic on {}", server.local_addr());
1849 server.into_handle()
1850 });
1851 Ok((server, admission_queue))
1852 }
1853
1854 pub fn state(&self) -> Arc<AuthorityState> {
1855 self.state.clone()
1856 }
1857
1858 pub fn embedded_rpc_store(&self) -> Option<&EmbeddedRpcStore> {
1864 self.embedded_rpc_store.as_ref()
1865 }
1866
1867 #[cfg(any(test, msim))]
1868 pub fn connection_monitor_handle_for_testing(
1869 &self,
1870 ) -> &mysten_network::anemo_connection_monitor::ConnectionMonitorHandle {
1871 &self._connection_monitor_handle
1872 }
1873
1874 #[cfg(any(test, msim))]
1875 pub fn address_prober_metrics_for_testing(
1876 &self,
1877 ) -> std::sync::Arc<address_prober::AddressProberMetrics> {
1878 self.address_prober
1879 .as_ref()
1880 .expect("address prober should be running in tests")
1881 .metrics_for_testing()
1882 }
1883
1884 #[cfg(feature = "testing")]
1885 pub fn prometheus_metrics_for_testing(&self) -> Vec<prometheus::proto::MetricFamily> {
1886 self.registry_service.default_registry().gather()
1887 }
1888
1889 pub fn node_role(&self) -> NodeRole {
1890 self.state.load_epoch_store_one_call_per_task().node_role()
1891 }
1892
1893 pub async fn consensus_adapter(&self) -> Option<Arc<ConsensusAdapter>> {
1898 self.validator_components
1899 .lock()
1900 .await
1901 .as_ref()
1902 .map(|c| c.consensus_adapter.clone())
1903 }
1904
1905 pub fn reference_gas_price_for_testing(&self) -> Result<u64, anyhow::Error> {
1907 self.state.reference_gas_price_for_testing()
1908 }
1909
1910 pub fn clone_committee_store(&self) -> Arc<CommitteeStore> {
1911 self.state.committee_store().clone()
1912 }
1913
1914 pub fn clone_checkpoint_store(&self) -> Arc<CheckpointStore> {
1915 self.checkpoint_store.clone()
1916 }
1917
1918 pub fn clone_authority_store(&self) -> Arc<AuthorityStore> {
1919 self.state.authority_store()
1920 }
1921
1922 pub fn clone_consensus_store(
1923 &self,
1924 ) -> Option<Arc<consensus_core::storage::rocksdb_store::RocksDBStore>> {
1925 self.validator_components
1926 .try_lock()
1927 .ok()?
1928 .as_ref()?
1929 .consensus_manager
1930 .consensus_store()
1931 }
1932
1933 pub fn clone_authority_aggregator(
1938 &self,
1939 ) -> Option<Arc<AuthorityAggregator<NetworkAuthorityClient>>> {
1940 self.transaction_orchestrator
1941 .as_ref()
1942 .map(|to| to.clone_authority_aggregator())
1943 }
1944
1945 pub fn transaction_orchestrator(
1946 &self,
1947 ) -> Option<Arc<TransactionOrchestrator<NetworkAuthorityClient>>> {
1948 self.transaction_orchestrator.clone()
1949 }
1950
1951 pub async fn monitor_reconfiguration(
1954 self: Arc<Self>,
1955 mut epoch_store: Arc<AuthorityPerEpochStore>,
1956 ) -> Result<()> {
1957 let checkpoint_executor_metrics =
1958 CheckpointExecutorMetrics::new(&self.registry_service.default_registry());
1959
1960 let mut broadcast_on_startup: Option<bool> =
1964 Some(self.config.peer_deny_sync_config.broadcast_on_startup);
1965
1966 loop {
1967 let mut hasher_guard = self.global_state_hasher.lock().await;
1968 let hasher = hasher_guard.take().unwrap();
1969 info!(
1970 "Creating checkpoint executor for epoch {}",
1971 epoch_store.epoch()
1972 );
1973 let checkpoint_executor = CheckpointExecutor::new(
1974 epoch_store.clone(),
1975 self.checkpoint_store.clone(),
1976 self.state.clone(),
1977 hasher.clone(),
1978 self.backpressure_manager.clone(),
1979 self.config.checkpoint_executor_config.clone(),
1980 checkpoint_executor_metrics.clone(),
1981 self.subscription_service_checkpoint_sender.clone(),
1982 self.locally_built_checkpoint_publisher.clone(),
1983 );
1984
1985 let run_with_range = self.config.run_with_range;
1986
1987 let cur_epoch_store = self.state.load_epoch_store_one_call_per_task();
1988
1989 self.metrics
1991 .current_protocol_version
1992 .set(cur_epoch_store.protocol_config().version.as_u64() as i64);
1993
1994 if let Some(components) = &*self.validator_components.lock().await
1997 && cur_epoch_store.is_validator()
1998 {
1999 tokio::time::sleep(Duration::from_millis(1)).await;
2001
2002 let config = cur_epoch_store.protocol_config();
2003 let mut supported_protocol_versions = self
2004 .config
2005 .supported_protocol_versions
2006 .expect("Supported versions should be populated")
2007 .truncate_below(config.version);
2009
2010 while supported_protocol_versions.max > config.version {
2011 let proposed_protocol_config = ProtocolConfig::get_for_version(
2012 supported_protocol_versions.max,
2013 cur_epoch_store.get_chain(),
2014 );
2015
2016 if proposed_protocol_config.enable_accumulators()
2017 && !epoch_store.accumulator_root_exists()
2018 {
2019 error!(
2020 "cannot upgrade to protocol version {:?} because accumulator root does not exist",
2021 supported_protocol_versions.max
2022 );
2023 supported_protocol_versions.max = supported_protocol_versions.max.prev();
2024 } else {
2025 break;
2026 }
2027 }
2028
2029 let binary_config = config.binary_config(None);
2030 let transaction = ConsensusTransaction::new_capability_notification_v2(
2031 AuthorityCapabilitiesV2::new(
2032 self.state.name,
2033 cur_epoch_store.get_chain_identifier().chain(),
2034 supported_protocol_versions,
2035 self.state
2036 .get_available_system_packages(&binary_config)
2037 .await,
2038 ),
2039 );
2040 info!(?transaction, "submitting capabilities to consensus");
2041 components.consensus_adapter.submit(
2042 transaction,
2043 None,
2044 &cur_epoch_store,
2045 None,
2046 None,
2047 )?;
2048
2049 if cur_epoch_store
2052 .protocol_config()
2053 .share_transaction_deny_config_in_consensus()
2054 {
2055 let sync_cfg = &self.config.peer_deny_sync_config;
2056 let is_startup = broadcast_on_startup.is_some();
2057 let should_broadcast = broadcast_on_startup
2058 .take()
2059 .unwrap_or(sync_cfg.broadcast_on_epoch_change);
2060 let manager = self.state.transaction_deny_config_manager();
2061 let publish = |rules: Option<TransactionDenyRules>| {
2062 if let Err(e) = manager.submit_broadcast(
2063 rules,
2064 &components.consensus_adapter,
2065 &cur_epoch_store,
2066 ) {
2067 warn!("Failed to broadcast transaction deny config: {e:?}");
2068 }
2069 };
2070 let action = deny_config_broadcast_payload(
2071 manager.local().rules(),
2072 should_broadcast,
2073 is_startup,
2074 manager.may_have_outstanding_broadcast(),
2075 );
2076 match action {
2077 DenyConfigBroadcastAction::Skip => {}
2078 DenyConfigBroadcastAction::Broadcast(rules) => publish(Some(rules)),
2079 DenyConfigBroadcastAction::Withdraw => publish(None),
2080 }
2081 }
2082 }
2083
2084 let stop_condition = checkpoint_executor.run_epoch(run_with_range).await;
2085
2086 if stop_condition == StopReason::RuntimeShutdown {
2087 return Ok(());
2088 }
2089
2090 if stop_condition == StopReason::RunWithRangeCondition {
2091 SuiNode::shutdown(&self).await;
2092 self.shutdown_channel_tx
2093 .send(run_with_range)
2094 .expect("RunWithRangeCondition met but failed to send shutdown message");
2095 return Ok(());
2096 }
2097
2098 let latest_system_state = self
2100 .state
2101 .get_object_cache_reader()
2102 .get_sui_system_state_object_unsafe()
2103 .expect("Read Sui System State object cannot fail");
2104
2105 #[cfg(msim)]
2106 if !self
2107 .sim_state
2108 .sim_safe_mode_expected
2109 .load(Ordering::Relaxed)
2110 {
2111 debug_assert!(!latest_system_state.safe_mode());
2112 }
2113
2114 #[cfg(not(msim))]
2115 debug_assert!(!latest_system_state.safe_mode());
2116
2117 if let Err(err) = self.end_of_epoch_channel.send(latest_system_state.clone())
2118 && self.state.is_fullnode(&cur_epoch_store)
2119 {
2120 warn!(
2121 "Failed to send end of epoch notification to subscriber: {:?}",
2122 err
2123 );
2124 }
2125
2126 cur_epoch_store.record_is_safe_mode_metric(latest_system_state.safe_mode());
2127 let new_epoch_start_state = latest_system_state.into_epoch_start_state();
2128
2129 self.auth_agg.store(Arc::new(
2130 self.auth_agg
2131 .load()
2132 .recreate_with_new_epoch_start_state(&new_epoch_start_state),
2133 ));
2134
2135 let next_epoch_committee = new_epoch_start_state.get_sui_committee();
2136 let next_epoch = next_epoch_committee.epoch();
2137 assert_eq!(cur_epoch_store.epoch() + 1, next_epoch);
2138
2139 info!(
2140 next_epoch,
2141 "Finished executing all checkpoints in epoch. About to reconfigure the system."
2142 );
2143
2144 fail_point_async!("reconfig_delay");
2145
2146 cur_epoch_store.record_epoch_reconfig_start_time_metric();
2147
2148 update_peer_addresses(
2149 &self.config,
2150 &self.endpoint_manager,
2151 &new_epoch_start_state,
2152 Some(cur_epoch_store.epoch_start_state()),
2153 );
2154
2155 let mut validator_components_lock_guard = self.validator_components.lock().await;
2156
2157 let new_epoch_store = self
2161 .reconfigure_state(
2162 &self.state,
2163 &cur_epoch_store,
2164 next_epoch_committee.clone(),
2165 new_epoch_start_state,
2166 hasher.clone(),
2167 )
2168 .await;
2169
2170 let new_role = new_epoch_store.node_role();
2171 if !new_role.is_validator()
2172 && let Some(context) = &self.transaction_pool_context
2173 {
2174 context.set_unavailable(next_epoch);
2175 }
2176
2177 let new_validator_components = if let Some(ValidatorComponents {
2178 validator_server_handle,
2179 validator_overload_monitor_handle,
2180 consensus_manager,
2181 consensus_store_pruner,
2182 consensus_adapter,
2183 checkpoint_metrics,
2184 sui_tx_validator_metrics,
2185 admission_queue,
2186 transaction_pool_context,
2187 }) = validator_components_lock_guard.take()
2188 {
2189 info!("Reconfiguring node (was running consensus).");
2190
2191 fail_point_async!("consensus_transaction_pool_reconfig_before_shutdown");
2192 consensus_manager.shutdown().await;
2193 info!("Consensus has shut down.");
2194
2195 let validator_server_handle = match validator_server_handle {
2199 Some(server) if !new_role.is_validator() => {
2200 info!("Node is no longer a validator, shutting down validator gRPC server");
2201 server.shutdown().await;
2202 None
2203 }
2204 other => other,
2205 };
2206
2207 if let Some(handle) = &self.address_prober {
2208 handle.leave_committee();
2209 }
2210
2211 info!("Epoch store finished reconfiguration.");
2212
2213 let global_state_hasher_metrics = Arc::into_inner(hasher)
2216 .expect("Object state hasher should have no other references at this point")
2217 .metrics();
2218 let new_hasher = Arc::new(GlobalStateHasher::new(
2219 self.state.get_global_state_hash_store().clone(),
2220 global_state_hasher_metrics,
2221 ));
2222 let weak_hasher = Arc::downgrade(&new_hasher);
2223 *hasher_guard = Some(new_hasher);
2224
2225 consensus_store_pruner.prune(next_epoch).await;
2226
2227 if new_role.runs_consensus() {
2228 info!("Restarting consensus as {new_role}");
2229 let components = Self::start_epoch_specific_validator_components(
2230 &self.config,
2231 self.state.clone(),
2232 consensus_adapter,
2233 self.checkpoint_store.clone(),
2234 new_epoch_store.clone(),
2235 self.state_sync_handle.clone(),
2236 self.randomness_handle.clone(),
2237 self.randomness_receiver_handle.clone(),
2238 consensus_manager,
2239 consensus_store_pruner,
2240 weak_hasher,
2241 self.backpressure_manager.clone(),
2242 validator_server_handle,
2243 validator_overload_monitor_handle,
2244 checkpoint_metrics,
2245 self.metrics.clone(),
2246 sui_tx_validator_metrics,
2247 admission_queue,
2248 transaction_pool_context.clone(),
2249 new_role,
2250 self.locally_built_checkpoint_publisher.clone(),
2251 )
2252 .await?;
2253 self.update_address_prober_epoch(
2254 &new_epoch_store,
2255 &components.consensus_manager,
2256 );
2257 Some(components)
2258 } else {
2259 info!(
2260 "This node has new role {new_role} and no longer runs consensus after reconfiguration"
2261 );
2262 None
2263 }
2264 } else {
2265 let global_state_hasher_metrics = Arc::into_inner(hasher)
2268 .expect("Object state hasher should have no other references at this point")
2269 .metrics();
2270 let new_hasher = Arc::new(GlobalStateHasher::new(
2271 self.state.get_global_state_hash_store().clone(),
2272 global_state_hasher_metrics,
2273 ));
2274 let weak_hasher = Arc::downgrade(&new_hasher);
2275 *hasher_guard = Some(new_hasher);
2276
2277 if new_role.runs_consensus() {
2278 info!("Promoting node to {new_role}, starting consensus components");
2279
2280 let mut components = Self::construct_validator_components(
2281 self.config.clone(),
2282 self.state.clone(),
2283 Arc::new(next_epoch_committee.clone()),
2284 new_epoch_store.clone(),
2285 self.checkpoint_store.clone(),
2286 self.state_sync_handle.clone(),
2287 self.randomness_handle.clone(),
2288 weak_hasher,
2289 self.backpressure_manager.clone(),
2290 &self.registry_service,
2291 self.transaction_pool_context.clone(),
2292 &self.consensus_adapter_metrics,
2293 self.metrics.clone(),
2294 self.checkpoint_metrics.clone(),
2295 new_role,
2296 self.randomness_receiver_handle.clone(),
2297 self.locally_built_checkpoint_publisher.clone(),
2298 )
2299 .await?;
2300
2301 if new_role.is_validator() {
2302 components.validator_server_handle = Some(
2303 components
2304 .validator_server_handle
2305 .take()
2306 .unwrap()
2307 .start()
2308 .await,
2309 );
2310
2311 self.endpoint_manager
2312 .set_consensus_address_updater(components.consensus_manager.clone());
2313 }
2314
2315 self.update_address_prober_epoch(
2316 &new_epoch_store,
2317 &components.consensus_manager,
2318 );
2319 Some(components)
2320 } else {
2321 None
2322 }
2323 };
2324 *validator_components_lock_guard = new_validator_components;
2325
2326 if cfg!(msim)
2327 && !matches!(
2328 self.config
2329 .authority_store_pruning_config
2330 .num_epochs_to_retain_for_checkpoints(),
2331 None | Some(u64::MAX) | Some(0)
2332 )
2333 {
2334 self.state
2335 .prune_checkpoints_for_eligible_epochs_for_testing(
2336 self.config.clone(),
2337 sui_core::authority::authority_store_pruner::AuthorityStorePruningMetrics::new_for_test(),
2338 )
2339 .await?;
2340 }
2341
2342 let prev_epoch = epoch_store.epoch();
2343 let prev_epoch_store = Arc::downgrade(&epoch_store);
2344 drop(cur_epoch_store);
2345 epoch_store = new_epoch_store;
2346 spawn_monitored_task!(Self::check_epoch_store_released(
2347 prev_epoch_store,
2348 prev_epoch
2349 ));
2350 info!("Reconfiguration finished");
2351 }
2352 }
2353
2354 async fn check_epoch_store_released(
2358 prev_epoch_store: Weak<AuthorityPerEpochStore>,
2359 prev_epoch: EpochId,
2360 ) {
2361 let grace_period = epoch_store_release_grace_period();
2362 tokio::time::sleep(grace_period).await;
2363 let strong_count = prev_epoch_store.strong_count();
2364 if strong_count > 0 {
2365 debug_fatal!(
2366 "AuthorityPerEpochStore for epoch {prev_epoch} still has {strong_count} strong \
2367 references {grace_period:?} after reconfiguration"
2368 );
2369 } else {
2370 info!(prev_epoch, "Previous epoch store released");
2371 }
2372 }
2373
2374 async fn shutdown(&self) {
2375 if let Some(validator_components) = &*self.validator_components.lock().await {
2376 validator_components.consensus_manager.shutdown().await;
2377 }
2378 if let Some(context) = &self.transaction_pool_context {
2379 context.set_unavailable(self.state.load_epoch_store_one_call_per_task().epoch());
2380 }
2381 }
2382
2383 async fn reconfigure_state(
2384 &self,
2385 state: &Arc<AuthorityState>,
2386 cur_epoch_store: &AuthorityPerEpochStore,
2387 next_epoch_committee: Committee,
2388 next_epoch_start_system_state: EpochStartSystemState,
2389 global_state_hasher: Arc<GlobalStateHasher>,
2390 ) -> Arc<AuthorityPerEpochStore> {
2391 let next_epoch = next_epoch_committee.epoch();
2392
2393 let last_checkpoint = self
2394 .checkpoint_store
2395 .get_epoch_last_checkpoint(cur_epoch_store.epoch())
2396 .expect("Error loading last checkpoint for current epoch")
2397 .expect("Could not load last checkpoint for current epoch");
2398
2399 let last_checkpoint_seq = *last_checkpoint.sequence_number();
2400
2401 assert_eq!(
2402 Some(last_checkpoint_seq),
2403 self.checkpoint_store
2404 .get_highest_executed_checkpoint_seq_number()
2405 .expect("Error loading highest executed checkpoint sequence number")
2406 );
2407
2408 let epoch_start_configuration = EpochStartConfiguration::new(
2409 next_epoch_start_system_state,
2410 *last_checkpoint.digest(),
2411 state.get_object_store().as_ref(),
2412 EpochFlag::default_flags_for_new_epoch(&state.config),
2413 )
2414 .expect("EpochStartConfiguration construction cannot fail");
2415
2416 let new_epoch_store = self
2417 .state
2418 .reconfigure(
2419 cur_epoch_store,
2420 self.config.supported_protocol_versions.unwrap(),
2421 next_epoch_committee,
2422 epoch_start_configuration,
2423 global_state_hasher,
2424 &self.config.expensive_safety_check_config,
2425 last_checkpoint_seq,
2426 )
2427 .await
2428 .expect("Reconfigure authority state cannot fail");
2429 info!(next_epoch, "Node State has been reconfigured");
2430 assert_eq!(next_epoch, new_epoch_store.epoch());
2431 self.state.get_reconfig_api().update_epoch_flags_metrics(
2432 cur_epoch_store.epoch_start_config().flags(),
2433 new_epoch_store.epoch_start_config().flags(),
2434 );
2435
2436 new_epoch_store
2437 }
2438
2439 pub fn get_config(&self) -> &NodeConfig {
2440 &self.config
2441 }
2442
2443 pub fn randomness_handle(&self) -> randomness::Handle {
2444 self.randomness_handle.clone()
2445 }
2446
2447 pub fn state_sync_handle(&self) -> state_sync::Handle {
2448 self.state_sync_handle.clone()
2449 }
2450
2451 pub fn endpoint_manager(&self) -> &EndpointManager {
2452 &self.endpoint_manager
2453 }
2454
2455 pub async fn address_prober_report(&self) -> Option<address_prober::ProbeReport> {
2456 match &self.address_prober {
2457 Some(handle) => handle.probe_report().await,
2458 None => None,
2459 }
2460 }
2461
2462 fn get_digest_prefix(digest: impl std::fmt::Display) -> String {
2464 let digest_str = digest.to_string();
2465 if digest_str.len() >= 8 {
2466 digest_str[0..8].to_string()
2467 } else {
2468 digest_str
2469 }
2470 }
2471
2472 async fn check_and_recover_forks(
2476 checkpoint_store: &CheckpointStore,
2477 checkpoint_metrics: &CheckpointMetrics,
2478 fork_recovery: Option<&ForkRecoveryConfig>,
2479 build_version: &str,
2480 ) -> Result<()> {
2481 if let Some(recovery) = fork_recovery {
2484 Self::try_recover_checkpoint_fork(checkpoint_store, recovery)?;
2485 Self::try_recover_transaction_fork(checkpoint_store, recovery)?;
2486 }
2487
2488 let behavior = fork_recovery
2489 .map(|fr| fr.fork_crash_behavior)
2490 .unwrap_or_default();
2491
2492 match behavior {
2493 ForkCrashBehavior::RecoverOncePerVersion => {
2494 Self::try_recover_forks(checkpoint_store, checkpoint_metrics, build_version)?;
2495 }
2496 ForkCrashBehavior::AwaitForkRecovery | ForkCrashBehavior::ReturnError => {}
2497 }
2498
2499 if let Some(fork_info) = checkpoint_store
2500 .get_checkpoint_fork_detected()
2501 .map_err(|e| {
2502 error!("Failed to check for checkpoint fork: {:?}", e);
2503 e
2504 })?
2505 {
2506 Self::handle_checkpoint_fork(
2507 fork_info.checkpoint_seq,
2508 fork_info.checkpoint_digest,
2509 checkpoint_metrics,
2510 fork_recovery,
2511 )
2512 .await?;
2513 }
2514 if let Some(fork_info) = checkpoint_store
2515 .get_transaction_fork_detected()
2516 .map_err(|e| {
2517 error!("Failed to check for transaction fork: {:?}", e);
2518 e
2519 })?
2520 {
2521 Self::handle_transaction_fork(
2522 fork_info.tx_digest,
2523 fork_info.expected_effects_digest,
2524 fork_info.actual_effects_digest,
2525 checkpoint_metrics,
2526 fork_recovery,
2527 )
2528 .await?;
2529 }
2530
2531 Ok(())
2532 }
2533
2534 fn try_recover_checkpoint_fork(
2538 checkpoint_store: &CheckpointStore,
2539 recovery: &ForkRecoveryConfig,
2540 ) -> Result<()> {
2541 if recovery.checkpoint_overrides.is_empty() {
2542 return Ok(());
2543 }
2544
2545 for (seq, expected_digest_str) in &recovery.checkpoint_overrides {
2546 let Ok(expected_digest) = CheckpointDigest::from_str(expected_digest_str) else {
2547 anyhow::bail!(
2548 "Invalid checkpoint digest override for seq {}: {}",
2549 seq,
2550 expected_digest_str
2551 );
2552 };
2553
2554 if let Some(local_summary) = checkpoint_store.get_locally_computed_checkpoint(*seq)? {
2555 let local_digest = sui_types::message_envelope::Message::digest(&local_summary);
2556 if local_digest != expected_digest {
2557 info!(
2558 seq,
2559 local = %Self::get_digest_prefix(local_digest),
2560 expected = %Self::get_digest_prefix(expected_digest),
2561 "Fork recovery: clearing locally_computed_checkpoints from {} due to digest mismatch",
2562 seq
2563 );
2564 checkpoint_store
2565 .clear_locally_computed_checkpoints_from(*seq)
2566 .context(
2567 "Failed to clear locally computed checkpoints from override seq",
2568 )?;
2569 }
2570 }
2571 }
2572
2573 if let Some(fork_info) = checkpoint_store.get_checkpoint_fork_detected()?
2574 && recovery
2575 .checkpoint_overrides
2576 .contains_key(&fork_info.checkpoint_seq)
2577 {
2578 info!(
2579 "Fork recovery enabled: clearing checkpoint fork at seq {} with digest {:?}",
2580 fork_info.checkpoint_seq, fork_info.checkpoint_digest
2581 );
2582 checkpoint_store
2583 .clear_checkpoint_fork_detected()
2584 .expect("Failed to clear checkpoint fork detected marker");
2585 }
2586 Ok(())
2587 }
2588
2589 fn try_recover_transaction_fork(
2592 checkpoint_store: &CheckpointStore,
2593 recovery: &ForkRecoveryConfig,
2594 ) -> Result<()> {
2595 if recovery.transaction_overrides.is_empty() {
2596 return Ok(());
2597 }
2598
2599 if let Some(fork_info) = checkpoint_store.get_transaction_fork_detected()?
2600 && recovery
2601 .transaction_overrides
2602 .contains_key(&fork_info.tx_digest.to_string())
2603 {
2604 info!(
2605 "Fork recovery enabled: clearing transaction fork for tx {:?}",
2606 fork_info.tx_digest
2607 );
2608 checkpoint_store
2609 .clear_transaction_fork_detected()
2610 .expect("Failed to clear transaction fork detected marker");
2611 }
2612 Ok(())
2613 }
2614
2615 fn try_recover_forks(
2633 checkpoint_store: &CheckpointStore,
2634 checkpoint_metrics: &CheckpointMetrics,
2635 build_version: &str,
2636 ) -> Result<()> {
2637 if let Some(fork_info) = checkpoint_store.get_checkpoint_fork_detected()? {
2638 if fork_info.binary_version == build_version {
2639 error!(
2640 checkpoint_seq = fork_info.checkpoint_seq,
2641 build_version,
2642 "Fork recovery blocked: this binary version produced the checkpoint fork and \
2643 would fork again. Halting; deploy a corrected binary to recover."
2644 );
2645 checkpoint_metrics
2646 .fork_auto_recovery_awaiting_new_binary
2647 .set(1);
2648 } else if fork_info.certified_checkpoint_digest.is_none() {
2649 error!(
2653 checkpoint_seq = fork_info.checkpoint_seq,
2654 checkpoint_digest = ?fork_info.checkpoint_digest,
2655 "Fork recovery blocked: the builder re-derived its own previous checkpoint \
2656 differently, so there is no certified checkpoint proving the canonical \
2657 outcome to converge toward. Halting awaiting operator intervention."
2658 );
2659 checkpoint_metrics
2660 .fork_auto_recovery_blocked_uncertified
2661 .set(1);
2662 } else {
2663 info!(
2664 checkpoint_seq = fork_info.checkpoint_seq,
2665 checkpoint_digest = ?fork_info.checkpoint_digest,
2666 forked_binary_version = ?fork_info.binary_version,
2667 build_version,
2668 "Fork recovery: clearing checkpoint fork and locally computed checkpoints \
2669 from the forked sequence so the builder rebuilds toward the certified \
2670 checkpoint"
2671 );
2672 checkpoint_store
2673 .clear_locally_computed_checkpoints_from(fork_info.checkpoint_seq)
2674 .context("Failed to clear locally computed checkpoints during fork recovery")?;
2675 checkpoint_store.clear_checkpoint_fork_detected()?;
2676 checkpoint_metrics.checkpoint_fork_auto_recovered.set(1);
2677 }
2678 }
2679
2680 if let Some(fork_info) = checkpoint_store.get_transaction_fork_detected()? {
2681 if fork_info.binary_version == build_version {
2682 error!(
2683 tx_digest = ?fork_info.tx_digest,
2684 build_version,
2685 "Fork recovery blocked: this binary version produced the transaction fork and \
2686 would fork again. Halting; deploy a corrected binary to recover."
2687 );
2688 checkpoint_metrics
2689 .fork_auto_recovery_awaiting_new_binary
2690 .set(1);
2691 } else if fork_info.certified_checkpoint_seq.is_none() {
2692 error!(
2693 tx_digest = ?fork_info.tx_digest,
2694 "Fork recovery blocked: the expected effects of the forked transaction did \
2695 not come from a certified checkpoint (they came from this validator's own \
2696 previously signed effects), so the network has not provably certified the \
2697 canonical outcome. Halting awaiting operator intervention."
2698 );
2699 checkpoint_metrics
2700 .fork_auto_recovery_blocked_uncertified
2701 .set(1);
2702 } else {
2703 info!(
2704 tx_digest = ?fork_info.tx_digest,
2705 expected_effects = ?fork_info.expected_effects_digest,
2706 actual_effects = ?fork_info.actual_effects_digest,
2707 certified_checkpoint_seq = ?fork_info.certified_checkpoint_seq,
2708 forked_binary_version = ?fork_info.binary_version,
2709 build_version,
2710 "Fork recovery: clearing transaction fork; re-execution will converge toward \
2711 the canonical certified effects"
2712 );
2713 checkpoint_store.clear_transaction_fork_detected()?;
2714 checkpoint_metrics.transaction_fork_auto_recovered.set(1);
2715 }
2716 }
2717
2718 Ok(())
2719 }
2720
2721 fn get_current_timestamp() -> u64 {
2722 std::time::SystemTime::now()
2723 .duration_since(std::time::SystemTime::UNIX_EPOCH)
2724 .unwrap()
2725 .as_secs()
2726 }
2727
2728 async fn handle_checkpoint_fork(
2729 checkpoint_seq: u64,
2730 checkpoint_digest: CheckpointDigest,
2731 checkpoint_metrics: &CheckpointMetrics,
2732 fork_recovery: Option<&ForkRecoveryConfig>,
2733 ) -> Result<()> {
2734 checkpoint_metrics
2735 .checkpoint_fork_crash_mode
2736 .with_label_values(&[
2737 &checkpoint_seq.to_string(),
2738 &Self::get_digest_prefix(checkpoint_digest),
2739 &Self::get_current_timestamp().to_string(),
2740 ])
2741 .set(1);
2742
2743 let behavior = fork_recovery
2744 .map(|fr| fr.fork_crash_behavior)
2745 .unwrap_or_default();
2746
2747 match behavior {
2748 ForkCrashBehavior::AwaitForkRecovery | ForkCrashBehavior::RecoverOncePerVersion => {
2749 error!(
2750 checkpoint_seq = checkpoint_seq,
2751 checkpoint_digest = ?checkpoint_digest,
2752 "Checkpoint fork detected! Node startup halted. Sleeping indefinitely."
2753 );
2754 futures::future::pending::<()>().await;
2755 unreachable!("pending() should never return");
2756 }
2757 ForkCrashBehavior::ReturnError => {
2758 error!(
2759 checkpoint_seq = checkpoint_seq,
2760 checkpoint_digest = ?checkpoint_digest,
2761 "Checkpoint fork detected! Returning error."
2762 );
2763 Err(anyhow::anyhow!(
2764 "Checkpoint fork detected! checkpoint_seq: {}, checkpoint_digest: {:?}",
2765 checkpoint_seq,
2766 checkpoint_digest
2767 ))
2768 }
2769 }
2770 }
2771
2772 async fn handle_transaction_fork(
2773 tx_digest: TransactionDigest,
2774 expected_effects_digest: TransactionEffectsDigest,
2775 actual_effects_digest: TransactionEffectsDigest,
2776 checkpoint_metrics: &CheckpointMetrics,
2777 fork_recovery: Option<&ForkRecoveryConfig>,
2778 ) -> Result<()> {
2779 checkpoint_metrics
2780 .transaction_fork_crash_mode
2781 .with_label_values(&[
2782 &Self::get_digest_prefix(tx_digest),
2783 &Self::get_digest_prefix(expected_effects_digest),
2784 &Self::get_digest_prefix(actual_effects_digest),
2785 &Self::get_current_timestamp().to_string(),
2786 ])
2787 .set(1);
2788
2789 let behavior = fork_recovery
2790 .map(|fr| fr.fork_crash_behavior)
2791 .unwrap_or_default();
2792
2793 match behavior {
2794 ForkCrashBehavior::AwaitForkRecovery | ForkCrashBehavior::RecoverOncePerVersion => {
2795 error!(
2796 tx_digest = ?tx_digest,
2797 expected_effects_digest = ?expected_effects_digest,
2798 actual_effects_digest = ?actual_effects_digest,
2799 "Transaction fork detected! Node startup halted. Sleeping indefinitely."
2800 );
2801 futures::future::pending::<()>().await;
2802 unreachable!("pending() should never return");
2803 }
2804 ForkCrashBehavior::ReturnError => {
2805 error!(
2806 tx_digest = ?tx_digest,
2807 expected_effects_digest = ?expected_effects_digest,
2808 actual_effects_digest = ?actual_effects_digest,
2809 "Transaction fork detected! Returning error."
2810 );
2811 Err(anyhow::anyhow!(
2812 "Transaction fork detected! tx_digest: {:?}, expected_effects: {:?}, actual_effects: {:?}",
2813 tx_digest,
2814 expected_effects_digest,
2815 actual_effects_digest
2816 ))
2817 }
2818 }
2819 }
2820}
2821
2822#[cfg(not(msim))]
2823impl SuiNode {
2824 async fn fetch_jwks(
2825 _authority: AuthorityName,
2826 provider: &OIDCProvider,
2827 ) -> SuiResult<Vec<(JwkId, JWK)>> {
2828 use fastcrypto_zkp::bn254::zk_login::fetch_jwks;
2829 use sui_types::error::SuiErrorKind;
2830 let client = reqwest::Client::new();
2831 fetch_jwks(provider, &client, true)
2832 .await
2833 .map_err(|_| SuiErrorKind::JWKRetrievalError.into())
2834 }
2835}
2836
2837#[cfg(msim)]
2838impl SuiNode {
2839 pub fn get_sim_node_id(&self) -> sui_simulator::task::NodeId {
2840 self.sim_state.sim_node.id()
2841 }
2842
2843 pub fn set_safe_mode_expected(&self, new_value: bool) {
2844 info!("Setting safe mode expected to {}", new_value);
2845 self.sim_state
2846 .sim_safe_mode_expected
2847 .store(new_value, Ordering::Relaxed);
2848 }
2849
2850 #[allow(unused_variables)]
2851 async fn fetch_jwks(
2852 authority: AuthorityName,
2853 provider: &OIDCProvider,
2854 ) -> SuiResult<Vec<(JwkId, JWK)>> {
2855 get_jwk_injector()(authority, provider)
2856 }
2857}
2858
2859enum ValidatorGrpcServer {
2862 Unstarted(Mutex<BoxFuture<'static, sui_http::ServerHandle>>),
2864 Started(sui_http::ServerHandle),
2865}
2866
2867impl ValidatorGrpcServer {
2868 pub fn new(bind: impl Future<Output = sui_http::ServerHandle> + Send + 'static) -> Self {
2869 Self::Unstarted(Mutex::new(Box::pin(bind)))
2870 }
2871
2872 pub async fn start(self) -> Self {
2873 match self {
2874 Self::Unstarted(bind) => Self::Started(bind.into_inner().await),
2875 Self::Started(_) => self,
2876 }
2877 }
2878
2879 pub async fn shutdown(self) {
2882 if let Self::Started(handle) = self {
2883 handle.trigger_shutdown();
2884 match tokio::time::timeout(
2885 VALIDATOR_GRPC_SERVER_SHUTDOWN_TIMEOUT,
2886 handle.wait_for_shutdown(),
2887 )
2888 .await
2889 {
2890 Ok(()) => info!("Validator gRPC server stopped"),
2891 Err(e) => warn!(
2893 error = ?e,
2894 "Validator gRPC server did not stop within {VALIDATOR_GRPC_SERVER_SHUTDOWN_TIMEOUT:?}"
2895 ),
2896 }
2897 }
2898 }
2899}
2900
2901fn update_peer_addresses(
2905 config: &NodeConfig,
2906 endpoint_manager: &EndpointManager,
2907 epoch_start_state: &EpochStartSystemState,
2908 prev_epoch_start_state: Option<&EpochStartSystemState>,
2909) {
2910 if config.consensus_config().is_none() {
2911 return;
2912 }
2913 let new_peers: HashSet<PeerId> = epoch_start_state
2914 .get_validator_as_p2p_peers(config.protocol_public_key())
2915 .into_iter()
2916 .map(|(peer_id, address)| {
2917 endpoint_manager
2918 .update_endpoint(
2919 EndpointId::P2p(peer_id),
2920 AddressSource::Chain,
2921 vec![address],
2922 )
2923 .expect("Updating peer addresses should not fail");
2924 peer_id
2925 })
2926 .collect();
2927
2928 if let Some(prev) = prev_epoch_start_state {
2930 for (peer_id, _) in prev.get_validator_as_p2p_peers(config.protocol_public_key()) {
2931 if !new_peers.contains(&peer_id) {
2932 endpoint_manager
2933 .update_endpoint(EndpointId::P2p(peer_id), AddressSource::Chain, vec![])
2934 .expect("Clearing peer addresses should not fail");
2935 }
2936 }
2937 }
2938}
2939
2940const LEGACY_INDEX_STORE_DIRS: [&str; 2] = ["rpc-index", "indexes"];
2944
2945fn remove_legacy_index_stores(db_path: &Path) {
2952 for dir in LEGACY_INDEX_STORE_DIRS {
2953 let legacy_dir = db_path.join(dir);
2954 match std::fs::remove_dir_all(&legacy_dir) {
2955 Ok(()) => info!("removed legacy {dir} directory {}", legacy_dir.display()),
2956 Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
2959 Err(e) => warn!(
2960 "failed to remove legacy {dir} directory {}: {e:?}",
2961 legacy_dir.display()
2962 ),
2963 }
2964 }
2965}
2966
2967async fn build_http_servers(
2968 state: Arc<AuthorityState>,
2969 store: RocksDbStore,
2970 transaction_orchestrator: &Option<Arc<TransactionOrchestrator<NetworkAuthorityClient>>>,
2971 config: &NodeConfig,
2972 prometheus_registry: &Registry,
2973 server_version: ServerVersion,
2974 node_role: NodeRole,
2975 embedded_rpc_store: Option<&EmbeddedRpcStore>,
2976) -> Result<(
2977 HttpServers,
2978 Option<tokio::sync::broadcast::Sender<Arc<Checkpoint>>>,
2979 Option<tokio::sync::broadcast::Sender<Arc<LocallyBuiltCheckpoint>>>,
2980)> {
2981 if !node_role.is_fullnode() {
2982 let Some(rpc_config) = config.rpc().filter(|rpc| rpc.enable_validator_rpc()) else {
2984 return Ok((HttpServers::default(), None, None));
2985 };
2986 rpc_config.validate()?;
2987 let (rpc_router, locally_built_checkpoint_sender) =
2988 build_validator_rpc_router(state, store, config, prometheus_registry, server_version)
2989 .await;
2990 return Ok((
2991 serve_rpc_router(config, rpc_config.http_address, rpc_router)?,
2992 None,
2993 Some(locally_built_checkpoint_sender),
2994 ));
2995 }
2996
2997 if let Some(rpc_config) = config.rpc() {
2998 anyhow::ensure!(
2999 !rpc_config.enable_validator_rpc(),
3000 "rpc.enable-validator-rpc is only valid on validators"
3001 );
3002 rpc_config.validate()?;
3003 }
3004
3005 info!("starting rpc service with config: {:?}", config.rpc);
3006
3007 let indexed_checkpoint = embedded_rpc_store.map(|embedded| embedded.indexed_checkpoint_fn());
3011 let subscription_watermark_interval = config
3012 .rpc
3013 .as_ref()
3014 .and_then(|rpc| rpc.subscription_watermark_interval);
3015 let subscription_max_subscribers = config
3016 .rpc
3017 .as_ref()
3018 .and_then(|rpc| rpc.subscription_max_subscribers);
3019 let subscription_shards = config.rpc.as_ref().and_then(|rpc| rpc.subscription_shards);
3020 let (subscription_service_checkpoint_sender, subscription_service_handle) =
3021 SubscriptionService::build(
3022 prometheus_registry,
3023 indexed_checkpoint,
3024 subscription_watermark_interval,
3025 subscription_max_subscribers,
3026 subscription_shards,
3027 );
3028 let rpc_router = {
3029 let reader: Arc<dyn RpcStateReader> = match embedded_rpc_store {
3033 Some(embedded) => Arc::new(RpcStoreReadStore::new(
3034 state.clone(),
3035 store,
3036 embedded.reader(),
3037 )),
3038 None => Arc::new(RestReadStore::new(state.clone(), store)),
3039 };
3040 let mut rpc_service = sui_rpc_api::RpcService::new(reader);
3041 rpc_service.with_server_version(server_version);
3042
3043 if let Some(config) = config.rpc.clone() {
3044 rpc_service.with_config(config);
3045 }
3046
3047 rpc_service.with_metrics(prometheus_registry);
3048 rpc_service.with_subscription_service(subscription_service_handle);
3049
3050 if let Some(transaction_orchestrator) = transaction_orchestrator {
3051 rpc_service.with_executor(transaction_orchestrator.clone());
3052 if config.enable_simulate_allowed_proposers {
3056 rpc_service
3057 .with_proposer_selector(transaction_orchestrator.transaction_driver().clone());
3058 }
3059 }
3060
3061 rpc_service.into_router().await
3062 };
3063
3064 let http_address = config.fullnode_http_address();
3065 if let Some(json_rpc_address) = config.json_rpc_address {
3066 warn!(
3067 %json_rpc_address,
3068 "json-rpc-address is deprecated and will be removed; set rpc.http-address instead, \
3069 which takes precedence"
3070 );
3071 }
3072
3073 Ok((
3074 serve_rpc_router(config, Some(http_address), rpc_router)?,
3075 Some(subscription_service_checkpoint_sender),
3076 None,
3077 ))
3078}
3079
3080fn serve_rpc_router(
3083 config: &NodeConfig,
3084 http_address: Option<std::net::SocketAddr>,
3085 rpc_router: axum::Router,
3086) -> Result<HttpServers> {
3087 let router = with_rpc_http_layers(rpc_router);
3088 let server_config = rpc_server_config(config);
3089
3090 let https = if let Some((tls_config, https_address)) = config
3091 .rpc()
3092 .and_then(|config| config.tls_config().map(|tls| (tls, config.https_address())))
3093 {
3094 let tls_server_config = https_rustls_config(tls_config.cert(), tls_config.key())?;
3095 let https = sui_http::Builder::new()
3096 .config(server_config.clone())
3097 .tls_config(tls_server_config)
3098 .serve(https_address, router.clone())
3099 .map_err(|e| anyhow::anyhow!(e))?;
3100
3101 info!(
3102 https_address =? https.local_addr(),
3103 "HTTPS rpc server listening on {}",
3104 https.local_addr()
3105 );
3106
3107 Some(https)
3108 } else {
3109 None
3110 };
3111
3112 let http = http_address
3113 .map(|http_address| -> Result<_> {
3114 let http = sui_http::Builder::new()
3115 .config(server_config)
3116 .serve(http_address, router)
3117 .map_err(|e| anyhow::anyhow!(e))?;
3118
3119 info!(
3120 http_address =? http.local_addr(),
3121 "HTTP rpc server listening on {}",
3122 http.local_addr()
3123 );
3124
3125 Ok(http)
3126 })
3127 .transpose()?;
3128
3129 Ok(HttpServers { http, https })
3130}
3131
3132async fn build_validator_rpc_router(
3137 state: Arc<AuthorityState>,
3138 store: RocksDbStore,
3139 config: &NodeConfig,
3140 prometheus_registry: &Registry,
3141 server_version: ServerVersion,
3142) -> (
3143 axum::Router,
3144 tokio::sync::broadcast::Sender<Arc<LocallyBuiltCheckpoint>>,
3145) {
3146 let rpc_config = config.rpc().cloned().unwrap_or_default();
3147 info!("starting validator rpc service with config: {rpc_config:?}");
3148
3149 let (locally_built_checkpoint_sender, subscription_service_handle) =
3150 SubscriptionService::build_for_locally_built_checkpoints(
3151 prometheus_registry,
3152 rpc_config.subscription_watermark_interval,
3153 rpc_config.subscription_max_subscribers,
3154 rpc_config.subscription_shards,
3155 );
3156
3157 let mut rpc_service = sui_rpc_api::RpcService::new(Arc::new(RestReadStore::new(state, store)));
3158 rpc_service.with_server_version(server_version);
3159 rpc_service.with_config(rpc_config);
3160 rpc_service.with_metrics(prometheus_registry);
3161 rpc_service.with_subscription_service(subscription_service_handle);
3162 rpc_service.with_validator_role();
3163
3164 (
3165 rpc_service.into_router().await,
3166 locally_built_checkpoint_sender,
3167 )
3168}
3169
3170fn with_rpc_http_layers(router: axum::Router) -> axum::Router {
3171 let layers = ServiceBuilder::new()
3172 .map_request(|mut request: axum::http::Request<_>| {
3173 if let Some(connect_info) = request.extensions().get::<sui_http::ConnectInfo>() {
3174 let axum_connect_info = axum::extract::ConnectInfo(connect_info.remote_addr);
3175 request.extensions_mut().insert(axum_connect_info);
3176 }
3177 request
3178 })
3179 .layer(axum::middleware::from_fn(server_timing_middleware))
3180 .layer(
3182 tower_http::cors::CorsLayer::new()
3183 .allow_methods([http::Method::GET, http::Method::POST])
3184 .allow_origin(tower_http::cors::Any)
3185 .allow_headers(tower_http::cors::Any)
3186 .expose_headers(tower_http::cors::Any),
3187 );
3188
3189 router.layer(layers)
3190}
3191
3192fn rpc_server_config(config: &NodeConfig) -> sui_http::Config {
3200 let rpc_config = config.rpc().cloned().unwrap_or_default();
3201 let mut server_config =
3202 sui_http::Config::default().max_connection_age_grace(rpc_config.max_connection_age_grace());
3203 if let Some(age) = rpc_config.max_connection_age() {
3204 server_config = server_config.max_connection_age(age);
3205 }
3206 server_config
3207}
3208
3209#[derive(Debug, PartialEq, Eq)]
3216enum DenyConfigBroadcastAction {
3217 Skip,
3219 Broadcast(TransactionDenyRules),
3221 Withdraw,
3223}
3224
3225fn deny_config_broadcast_payload(
3226 local_rules: &TransactionDenyRules,
3227 broadcast: bool,
3228 is_startup: bool,
3229 may_have_prior_broadcast: bool,
3230) -> DenyConfigBroadcastAction {
3231 let shareable = local_rules.is_empty() || local_rules.check_share_limits().is_ok();
3232 if broadcast && shareable {
3233 if local_rules.is_empty() {
3235 DenyConfigBroadcastAction::Withdraw
3236 } else {
3237 DenyConfigBroadcastAction::Broadcast(local_rules.clone())
3238 }
3239 } else if is_startup && may_have_prior_broadcast {
3240 DenyConfigBroadcastAction::Withdraw
3241 } else {
3242 DenyConfigBroadcastAction::Skip
3243 }
3244}
3245
3246fn https_rustls_config(cert: &str, key: &str) -> Result<sui_http::rustls::ServerConfig> {
3255 use sui_http::rustls;
3256 use sui_http::rustls::pki_types::pem::PemObject;
3257
3258 let certs = rustls::pki_types::CertificateDer::pem_file_iter(cert)
3259 .with_context(|| format!("failed to read TLS certificate chain from {cert}"))?
3260 .collect::<Result<Vec<_>, _>>()
3261 .with_context(|| format!("failed to parse TLS certificate chain from {cert}"))?;
3262 let private_key = rustls::pki_types::PrivateKeyDer::from_pem_file(key)
3263 .with_context(|| format!("failed to read TLS private key from {key}"))?;
3264 let config = rustls::ServerConfig::builder_with_provider(Arc::new(
3265 rustls::crypto::ring::default_provider(),
3266 ))
3267 .with_protocol_versions(rustls::DEFAULT_VERSIONS)?
3268 .with_no_client_auth()
3269 .with_single_cert(certs, private_key)?;
3270 Ok(config)
3271}
3272
3273#[derive(Default)]
3274struct HttpServers {
3275 #[allow(unused)]
3276 http: Option<sui_http::ServerHandle>,
3277 #[allow(unused)]
3278 https: Option<sui_http::ServerHandle>,
3279}
3280
3281#[cfg(test)]
3282mod tests {
3283 use super::*;
3284 use prometheus::Registry;
3285 use std::collections::BTreeMap;
3286 use sui_config::node::{ForkCrashBehavior, ForkRecoveryConfig};
3287 use sui_core::checkpoints::{CheckpointMetrics, CheckpointStore};
3288 use sui_types::digests::{CheckpointDigest, TransactionDigest, TransactionEffectsDigest};
3289
3290 #[test]
3291 fn deny_config_broadcast_payload_decisions() {
3292 let empty = TransactionDenyRules::default();
3293 let populated = TransactionDenyRules {
3294 package_publish_disabled: true,
3295 ..Default::default()
3296 };
3297 let oversized = TransactionDenyRules {
3298 zklogin_disabled_providers: std::iter::once(
3299 "x".repeat(TransactionDenyRules::MAX_ZKLOGIN_PROVIDER_LENGTH + 1),
3300 )
3301 .collect(),
3302 ..Default::default()
3303 };
3304
3305 assert_eq!(
3307 deny_config_broadcast_payload(&populated, true, true, false),
3308 DenyConfigBroadcastAction::Broadcast(populated.clone()),
3309 );
3310 assert_eq!(
3312 deny_config_broadcast_payload(&empty, true, true, false),
3313 DenyConfigBroadcastAction::Withdraw,
3314 );
3315 assert_eq!(
3317 deny_config_broadcast_payload(&populated, false, true, true),
3318 DenyConfigBroadcastAction::Withdraw,
3319 );
3320 assert_eq!(
3322 deny_config_broadcast_payload(&populated, false, true, false),
3323 DenyConfigBroadcastAction::Skip,
3324 );
3325 assert_eq!(
3327 deny_config_broadcast_payload(&populated, false, false, true),
3328 DenyConfigBroadcastAction::Skip,
3329 );
3330 assert_eq!(
3333 deny_config_broadcast_payload(&oversized, true, true, true),
3334 DenyConfigBroadcastAction::Withdraw,
3335 );
3336 assert_eq!(
3337 deny_config_broadcast_payload(&oversized, true, true, false),
3338 DenyConfigBroadcastAction::Skip,
3339 );
3340 }
3341
3342 #[test]
3346 fn removes_only_the_legacy_index_directories() {
3347 let db = tempfile::tempdir().unwrap();
3348 let rpc_index = db.path().join("rpc-index");
3349 let indexes = db.path().join("indexes");
3350 let sibling = db.path().join("store");
3351 for dir in [&rpc_index, &indexes, &sibling] {
3352 std::fs::create_dir(dir).unwrap();
3353 std::fs::write(dir.join("CURRENT"), b"stale").unwrap();
3354 }
3355
3356 remove_legacy_index_stores(db.path());
3357 assert!(
3358 !rpc_index.exists(),
3359 "legacy rpc-index directory should be gone"
3360 );
3361 assert!(!indexes.exists(), "legacy indexes directory should be gone");
3362 assert!(sibling.exists(), "sibling stores must be left untouched");
3363
3364 remove_legacy_index_stores(db.path());
3367 assert!(!rpc_index.exists());
3368 assert!(!indexes.exists());
3369 assert!(sibling.exists());
3370 }
3371
3372 #[tokio::test]
3374 async fn test_return_error_does_not_recover() {
3375 let checkpoint_store = CheckpointStore::new_for_tests();
3376 let checkpoint_metrics = CheckpointMetrics::new(&Registry::new());
3377 let cfg = ForkRecoveryConfig {
3378 transaction_overrides: Default::default(),
3379 checkpoint_overrides: Default::default(),
3380 fork_crash_behavior: ForkCrashBehavior::ReturnError,
3381 };
3382
3383 checkpoint_store
3385 .record_checkpoint_fork_detected(
3386 42,
3387 CheckpointDigest::random(),
3388 Some(CheckpointDigest::random()),
3389 )
3390 .unwrap();
3391 let r = SuiNode::check_and_recover_forks(
3392 &checkpoint_store,
3393 &checkpoint_metrics,
3394 Some(&cfg),
3395 "v1",
3396 )
3397 .await;
3398 assert!(
3399 r.unwrap_err()
3400 .to_string()
3401 .contains("Checkpoint fork detected")
3402 );
3403 assert!(
3404 checkpoint_store
3405 .get_checkpoint_fork_detected()
3406 .unwrap()
3407 .is_some()
3408 );
3409 checkpoint_store.clear_checkpoint_fork_detected().unwrap();
3410
3411 checkpoint_store
3413 .record_transaction_fork_detected(
3414 TransactionDigest::random(),
3415 TransactionEffectsDigest::random(),
3416 TransactionEffectsDigest::random(),
3417 Some(1),
3418 )
3419 .unwrap();
3420 let r = SuiNode::check_and_recover_forks(
3421 &checkpoint_store,
3422 &checkpoint_metrics,
3423 Some(&cfg),
3424 "v1",
3425 )
3426 .await;
3427 assert!(
3428 r.unwrap_err()
3429 .to_string()
3430 .contains("Transaction fork detected")
3431 );
3432 }
3433
3434 #[tokio::test]
3438 async fn test_same_binary_version_does_not_recover() {
3439 let checkpoint_store = CheckpointStore::new_for_tests();
3440 let checkpoint_metrics = CheckpointMetrics::new(&Registry::new());
3441 let seq = 7;
3442 checkpoint_store.set_binary_version("v1");
3444 checkpoint_store
3445 .record_checkpoint_fork_detected(
3446 seq,
3447 CheckpointDigest::random(),
3448 Some(CheckpointDigest::random()),
3449 )
3450 .unwrap();
3451
3452 SuiNode::try_recover_forks(&checkpoint_store, &checkpoint_metrics, "v1").unwrap();
3454 assert!(
3455 checkpoint_store
3456 .get_checkpoint_fork_detected()
3457 .unwrap()
3458 .is_some()
3459 );
3460 assert_eq!(
3461 checkpoint_metrics
3462 .fork_auto_recovery_awaiting_new_binary
3463 .get(),
3464 1
3465 );
3466 assert_eq!(checkpoint_metrics.checkpoint_fork_auto_recovered.get(), 0);
3467
3468 SuiNode::try_recover_forks(&checkpoint_store, &checkpoint_metrics, "v2").unwrap();
3470 assert!(
3471 checkpoint_store
3472 .get_checkpoint_fork_detected()
3473 .unwrap()
3474 .is_none()
3475 );
3476 assert_eq!(checkpoint_metrics.checkpoint_fork_auto_recovered.get(), 1);
3477 }
3478
3479 #[tokio::test]
3481 async fn test_default_recovers() {
3482 let checkpoint_store = CheckpointStore::new_for_tests();
3483 let checkpoint_metrics = CheckpointMetrics::new(&Registry::new());
3484
3485 let tx_digest = TransactionDigest::random();
3486 checkpoint_store.set_binary_version("v1");
3489 checkpoint_store
3490 .record_transaction_fork_detected(
3491 tx_digest,
3492 TransactionEffectsDigest::random(),
3493 TransactionEffectsDigest::random(),
3494 Some(3),
3495 )
3496 .unwrap();
3497
3498 let r =
3499 SuiNode::check_and_recover_forks(&checkpoint_store, &checkpoint_metrics, None, "v2")
3500 .await;
3501 assert!(r.is_ok());
3502 assert!(
3503 checkpoint_store
3504 .get_transaction_fork_detected()
3505 .unwrap()
3506 .is_none()
3507 );
3508 assert_eq!(checkpoint_metrics.transaction_fork_auto_recovered.get(), 1);
3509 }
3510
3511 #[tokio::test]
3514 async fn test_checkpoint_overrides_clear_checkpoint_marker_only() {
3515 let checkpoint_store = CheckpointStore::new_for_tests();
3516 let seq = 9;
3517
3518 checkpoint_store
3519 .record_checkpoint_fork_detected(
3520 seq,
3521 CheckpointDigest::random(),
3522 Some(CheckpointDigest::random()),
3523 )
3524 .unwrap();
3525 checkpoint_store
3526 .record_transaction_fork_detected(
3527 TransactionDigest::random(),
3528 TransactionEffectsDigest::random(),
3529 TransactionEffectsDigest::random(),
3530 None,
3531 )
3532 .unwrap();
3533
3534 SuiNode::try_recover_checkpoint_fork(&checkpoint_store, &ForkRecoveryConfig::default())
3536 .unwrap();
3537 assert!(
3538 checkpoint_store
3539 .get_checkpoint_fork_detected()
3540 .unwrap()
3541 .is_some()
3542 );
3543 assert!(
3544 checkpoint_store
3545 .get_transaction_fork_detected()
3546 .unwrap()
3547 .is_some()
3548 );
3549
3550 let mut checkpoint_overrides = BTreeMap::new();
3552 checkpoint_overrides.insert(seq, CheckpointDigest::random().to_string());
3553 let cfg = ForkRecoveryConfig {
3554 transaction_overrides: Default::default(),
3555 checkpoint_overrides,
3556 fork_crash_behavior: ForkCrashBehavior::AwaitForkRecovery,
3557 };
3558 SuiNode::try_recover_checkpoint_fork(&checkpoint_store, &cfg).unwrap();
3559 assert!(
3560 checkpoint_store
3561 .get_checkpoint_fork_detected()
3562 .unwrap()
3563 .is_none()
3564 );
3565 assert!(
3566 checkpoint_store
3567 .get_transaction_fork_detected()
3568 .unwrap()
3569 .is_some(),
3570 "checkpoint_overrides must not touch the transaction fork marker"
3571 );
3572 }
3573
3574 #[tokio::test]
3576 async fn test_transaction_overrides_clear_transaction_marker() {
3577 let checkpoint_store = CheckpointStore::new_for_tests();
3578 let tx_digest = TransactionDigest::random();
3579 checkpoint_store
3580 .record_transaction_fork_detected(
3581 tx_digest,
3582 TransactionEffectsDigest::random(),
3583 TransactionEffectsDigest::random(),
3584 None,
3585 )
3586 .unwrap();
3587
3588 let mut transaction_overrides = BTreeMap::new();
3590 transaction_overrides.insert(TransactionDigest::random().to_string(), String::new());
3591 let cfg = ForkRecoveryConfig {
3592 transaction_overrides,
3593 checkpoint_overrides: Default::default(),
3594 fork_crash_behavior: ForkCrashBehavior::AwaitForkRecovery,
3595 };
3596 SuiNode::try_recover_transaction_fork(&checkpoint_store, &cfg).unwrap();
3597 assert!(
3598 checkpoint_store
3599 .get_transaction_fork_detected()
3600 .unwrap()
3601 .is_some()
3602 );
3603
3604 let mut transaction_overrides = BTreeMap::new();
3606 transaction_overrides.insert(tx_digest.to_string(), String::new());
3607 let cfg = ForkRecoveryConfig {
3608 transaction_overrides,
3609 checkpoint_overrides: Default::default(),
3610 fork_crash_behavior: ForkCrashBehavior::AwaitForkRecovery,
3611 };
3612 SuiNode::try_recover_transaction_fork(&checkpoint_store, &cfg).unwrap();
3613 assert!(
3614 checkpoint_store
3615 .get_transaction_fork_detected()
3616 .unwrap()
3617 .is_none()
3618 );
3619 }
3620
3621 #[tokio::test]
3625 async fn test_override_clears_fork_auto_recovery_refuses() {
3626 let checkpoint_store = CheckpointStore::new_for_tests();
3627 let checkpoint_metrics = CheckpointMetrics::new(&Registry::new());
3628 let seq = 5;
3629 checkpoint_store.set_binary_version("v1");
3630 checkpoint_store
3631 .record_checkpoint_fork_detected(
3632 seq,
3633 CheckpointDigest::random(),
3634 Some(CheckpointDigest::random()),
3635 )
3636 .unwrap();
3637
3638 let mut checkpoint_overrides = BTreeMap::new();
3639 checkpoint_overrides.insert(seq, CheckpointDigest::random().to_string());
3640 let cfg = ForkRecoveryConfig {
3641 transaction_overrides: Default::default(),
3642 checkpoint_overrides,
3643 fork_crash_behavior: ForkCrashBehavior::RecoverOncePerVersion,
3644 };
3645
3646 SuiNode::check_and_recover_forks(&checkpoint_store, &checkpoint_metrics, Some(&cfg), "v1")
3647 .await
3648 .unwrap();
3649
3650 assert!(
3651 checkpoint_store
3652 .get_checkpoint_fork_detected()
3653 .unwrap()
3654 .is_none()
3655 );
3656 }
3657
3658 #[tokio::test]
3663 async fn test_self_divergence_checkpoint_fork_blocks_recovery() {
3664 let checkpoint_store = CheckpointStore::new_for_tests();
3665 let checkpoint_metrics = CheckpointMetrics::new(&Registry::new());
3666 let seq = 17;
3667 checkpoint_store.set_binary_version("v1");
3668 checkpoint_store
3669 .record_checkpoint_fork_detected(seq, CheckpointDigest::random(), None)
3670 .unwrap();
3671
3672 SuiNode::try_recover_forks(&checkpoint_store, &checkpoint_metrics, "v2").unwrap();
3673
3674 assert!(
3675 checkpoint_store
3676 .get_checkpoint_fork_detected()
3677 .unwrap()
3678 .is_some()
3679 );
3680 assert_eq!(
3681 checkpoint_metrics
3682 .fork_auto_recovery_blocked_uncertified
3683 .get(),
3684 1
3685 );
3686 assert_eq!(checkpoint_metrics.checkpoint_fork_auto_recovered.get(), 0);
3687 }
3688
3689 #[tokio::test]
3693 async fn test_uncertified_transaction_fork_blocks_recovery() {
3694 let checkpoint_store = CheckpointStore::new_for_tests();
3695 let checkpoint_metrics = CheckpointMetrics::new(&Registry::new());
3696 checkpoint_store.set_binary_version("v1");
3697 checkpoint_store
3698 .record_transaction_fork_detected(
3699 TransactionDigest::random(),
3700 TransactionEffectsDigest::random(),
3701 TransactionEffectsDigest::random(),
3702 None,
3703 )
3704 .unwrap();
3705
3706 SuiNode::try_recover_forks(&checkpoint_store, &checkpoint_metrics, "v2").unwrap();
3707 SuiNode::try_recover_forks(&checkpoint_store, &checkpoint_metrics, "v3").unwrap();
3708
3709 assert!(
3710 checkpoint_store
3711 .get_transaction_fork_detected()
3712 .unwrap()
3713 .is_some()
3714 );
3715 assert_eq!(
3716 checkpoint_metrics
3717 .fork_auto_recovery_blocked_uncertified
3718 .get(),
3719 1
3720 );
3721 }
3722}