Skip to main content

sui_node/
lib.rs

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