Struct EmbeddedRpcStore 

pub struct EmbeddedRpcStore { /* private fields */ }

A bootstrapped embedded rpc-store, ready to hand to the pruner and the rpc-api read path and to start tip indexing.

Implementations

impl EmbeddedRpcStore

pub async fn bootstrap( config: &NodeConfig, authority_store: &Arc<AuthorityStore>, checkpoint_store: &Arc<CheckpointStore>, ingestion_source: RocksDbStore, chain_identifier: ChainIdentifier, registry: &Registry, ) -> Result<Self>

Open the rpc-store, bring it in line with the perpetual store’s available range (restoring / seeding as needed), and build the store and read handles.

Blocks while restoring the live cohort. Call before the node starts executing checkpoints, so the perpetual store’s range is stable for the duration of the restore.

pub fn bootstrap_action(&self) -> Bootstrap

The bootstrap action selected for the on-disk store at startup: whether this run resumed the existing indexes, re-seeded the history cohort, or rebuilt the live cohort. Read-only introspection; primarily for tests.

pub fn live_committed_checkpoint(&self) -> Option<u64>

The highest checkpoint the live cohort has committed (min(checkpoint_hi_inclusive) across its pipelines), i.e. how far the live-object indexes have caught up to the tip. None until every live pipeline has a watermark. Read-only introspection; primarily for tests.

pub fn history_committed_checkpoint(&self) -> Option<u64>

The highest checkpoint the history cohort has committed, i.e. how far the ledger-history backfill has progressed. None until every history pipeline has a watermark. Read-only introspection; primarily for tests.

pub fn store(&self) -> RpcStore

A clone of the store handle, for the pruner’s history-cohort pruning (sui_rpc_store::prune_history_cohort).

pub fn reader(&self) -> RpcStoreReader

A clone of the read handle, for the rpc-api read path (crate::storage::RpcStoreReadStore).

pub fn indexed_checkpoint_fn( &self, ) -> Arc<dyn Fn() -> Option<u64> + Send + Sync>

A callback reading the highest checkpoint the live cohort has committed, for the subscription service’s index gate (so a checkpoint is not delivered to clients until its indexed state is readable).

Reads only the live cohort: the history cohort backfills independently from the lowest available checkpoint, so gating on it would hold back delivery on a restored node for the duration of the backfill. On a node indexing from genesis the synchronizer keeps the cohorts in lockstep, so the live cohort’s progress implies the history cohort’s.

pub fn spawn_indexer( &mut self, checkpoint_sender: Option<Sender<Arc<Checkpoint>>>, registry: Registry, )

Spawn a background task that builds and runs the tip-following indexer over the embedded store.

The indexer is built on a background task – rather than inline – because the framework reads the starting tip via latest_checkpoint_number, which on a node booting from genesis blocks until the first checkpoint has been executed. At this point genesis is only synced (the executor has not run yet), so the read retries until the checkpoint executor catches up; that executor only starts once start_async returns, so building inline would deadlock node startup against a checkpoint that cannot arrive until startup completes. (A resuming node has an executed tip on disk and would not block, but the genesis case forces the deferral unconditionally.) The follower catches up once checkpoints begin to flow.

The background task is held as a single-task Service so the node owns the indexer’s lifetime: dropping EmbeddedRpcStore drops this service, which aborts the task and, with it, the inner indexer service it is joining.

checkpoint_sender is the checkpoint executor’s broadcast stream; when present it drives a low-latency BroadcastStreamingClient, with the perpetual-store ingestion client filling any gap. When absent (e.g. on a node that does not run the rpc servers) the ingestion client polls the perpetual store alone.