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