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