Struct RpcStoreSchema 

pub struct RpcStoreSchema<R: Reader = Db> {

    pub epochs: DbMap<Key, Value, R>,
    pub checkpoint_summary: DbMap<Key, Value, R>,
    pub checkpoint_contents: DbMap<Key, Value, R>,
    pub checkpoint_seq_by_digest: DbMap<Key, Value, R>,
    pub transactions: DbMap<Key, Value, R>,
    pub tx_seq_by_digest: DbMap<Key, Value, R>,
    pub tx_metadata_by_seq: DbMap<Key, Value, R>,
    pub effects: DbMap<Key, Value, R>,
    pub events: DbMap<Key, Value, R>,
    pub objects: DbMap<Key, Value, R>,
    pub object_version_by_checkpoint: DbMap<Key, Value, R>,
    pub object_by_owner: DbMap<Key, Value, R>,
    pub object_by_type: DbMap<Key, Value, R>,
    pub balance: DbMap<Key, Value, R>,
    pub package_versions: DbMap<Key, Value, R>,
    pub transaction_bitmap: DbMap<Key, Value, R>,
    pub event_bitmap: DbMap<Key, Value, R>,
    pub pruning_watermark: DbMap<Key, Value, R>,
}

Typed handles to every CF in the sui-rpc-store layout.

Fields

epochs: DbMap<Key, Value, R>

Per-epoch metadata: protocol version, gas price, start and end timestamps, and the epoch’s final checkpoint.

checkpoint_summary: DbMap<Key, Value, R>

Signed checkpoint headers. The lightweight metadata served by most “fetch a checkpoint” requests; the heavier contents list lives in a separate CF.

checkpoint_contents: DbMap<Key, Value, R>

The ordered list of executed transaction digests in each checkpoint.

checkpoint_seq_by_digest: DbMap<Key, Value, R>

Resolves a checkpoint digest to its sequence number, which is then the key for every other checkpoint-keyed CF.

transactions: DbMap<Key, Value, R>

Signed transactions, keyed by their assigned tx_seq.

tx_seq_by_digest: DbMap<Key, Value, R>

Resolves a transaction digest to its assigned tx_seq.

tx_metadata_by_seq: DbMap<Key, Value, R>

Per-transaction metadata: digest, the containing checkpoint, position within that checkpoint, event count, and the checkpoint’s timestamp.

effects: DbMap<Key, Value, R>

The effects produced by each transaction, together with the set of objects loaded but unchanged during execution.

events: DbMap<Key, Value, R>

The events emitted by each transaction.

objects: DbMap<Key, Value, R>

Every version of every object that has ever existed. A prefix scan on the object id walks all versions in ascending order; a reverse prefix scan resolves the latest version (the greatest (id, version) row), the way the validator perpetual store serves “latest object” reads.

object_version_by_checkpoint: DbMap<Key, Value, R>

An object’s version as of a checkpoint: keyed by (object id, checkpoint), a reverse prefix scan resolves the version live at the end of the most recent checkpoint, at or before the one queried, in which the object changed. Backs checkpoint-pinned historical reads that the version-keyed objects CF cannot answer.

object_by_owner: DbMap<Key, Value, R>

Supports listing an owner’s objects, optionally filtered by Move type. Coin-like objects sort richest-first within each (owner, type) group so paginating valuable holdings is a forward prefix scan.

object_by_type: DbMap<Key, Value, R>

Supports listing every live object of a given Move type, regardless of owner.

balance: DbMap<Key, Value, R>

Tracks an account’s balance per coin type, combining the coin-derived component (sum of owned Coin<T> balances) and the accumulator-derived component into a single row merged from independent indexer pipelines.

package_versions: DbMap<Key, Value, R>

Tracks every published version of a Move package and the storage id under which each version lives.

transaction_bitmap: DbMap<Key, Value, R>

Inverted bitmap index over transaction-sequence space, supporting filtered transaction queries by indexed fields such as sender, called function, or input/changed object.

event_bitmap: DbMap<Key, Value, R>

Inverted bitmap index over packed event-sequence space, supporting filtered event queries by event type, emitting module, sender, and similar indexed fields.

pruning_watermark: DbMap<Key, Value, R>

Singleton holding the lowest still-available tx_seq, checkpoint_seq, and object version. Drives compaction filters and feeds available_range responses.

Implementations

impl<R: Reader> RpcStoreSchema<R>

pub fn get_balance( &self, owner: SuiAddress, coin_type: TypeTag, ) -> Result<Option<Balance>, Error>

Look up the aggregated balance for (owner, coin_type).

pub fn iter_balances_owned_by( &self, owner: SuiAddress, ) -> Result<Iter<'_, Key, Value>, Error>

Iterate every coin type that owner has a balance in.

impl<R: Reader> RpcStoreSchema<R>

pub fn get_checkpoint_contents( &self, seq: CheckpointSequenceNumber, ) -> Result<Option<CheckpointContents>, Error>

Look up the contents of a checkpoint by sequence number.

impl<R: Reader> RpcStoreSchema<R>

pub fn get_checkpoint_seq_by_digest( &self, digest: &CheckpointDigest, ) -> Result<Option<CheckpointSequenceNumber>, Error>

Look up the sequence number of the checkpoint identified by digest.

impl<R: Reader> RpcStoreSchema<R>

pub fn get_checkpoint_summary( &self, seq: CheckpointSequenceNumber, ) -> Result<Option<VerifiedCheckpoint>, Error>

Look up the signed summary of a checkpoint by sequence number.

Decodes the stored BCS payloads and rewraps them as a VerifiedCheckpoint. The “verified” tag is asserted via new_unchecked: we trust what we put in our own store.

impl<R: Reader> RpcStoreSchema<R>

pub fn get_effects( &self, tx_seq: u64, ) -> Result<Option<(TransactionEffects, Vec<ObjectKey>)>, Error>

Look up the effects produced by the transaction at the given assigned tx_seq, along with the set of objects loaded during execution but not modified by the tx.

impl<R: Reader> RpcStoreSchema<R>

pub fn get_epoch(&self, epoch: EpochId) -> Result<Option<EpochInfo>, Error>

Look up the metadata for an epoch, decoding the embedded BCS SuiSystemState into the canonical sui_types::storage::EpochInfo.

pub fn get_committee(&self, epoch: EpochId) -> Result<Option<Committee>, Error>

Look up the validator committee active during an epoch.

Derived from the stored SuiSystemState rather than kept in its own CF — the system state already carries the validator set, so a dedicated committee row would just be duplicate bytes. Returns Ok(None) if no epoch row exists or if the epoch row exists but no system_state_bcs has been observed yet.

impl<R: Reader> RpcStoreSchema<R>

pub fn get_event_bitmap( &self, dimension_key: Vec<u8>, bucket: u64, ) -> Result<Option<RoaringBitmap>, Error>

Look up the event bitmap for (dimension_key, bucket) and return it deserialized.

pub fn iter_event_bitmap_buckets( &self, dimension_key: Vec<u8>, ) -> Result<Iter<'_, Key, Value>, Error>

Iterate every bucket recorded against dimension_key, in ascending bucket order.

impl<R: Reader> RpcStoreSchema<R>

pub fn get_events( &self, tx_seq: u64, ) -> Result<Option<TransactionEvents>, Error>

Look up the events emitted by the transaction at the given assigned tx_seq.

impl<R: Reader> RpcStoreSchema<R>

pub fn iter_objects_owned_by_address( &self, owner: SuiAddress, ) -> Result<Iter<'_, Key, U64Varint>, Error>

Iterate over every live object owned (in the address-owner sense) by owner, in the natural sort order of the index: by Move type, then within each type by descending balance for coin-like objects, then by object id.

pub fn iter_objects_owned_by_address_of_type( &self, owner: SuiAddress, type_filter: TypeFilter, ) -> Result<Iter<'_, Key, U64Varint>, Error>

Iterate over every live object owned (in the address-owner sense) by owner whose Move type matches type_filter. See type_filter::TypeFilter for the matching contract.

pub fn iter_objects_owned_by_object( &self, parent: SuiAddress, ) -> Result<Iter<'_, Key, U64Varint>, Error>

Iterate over every live object owned (in the object-owner sense) by the parent object at the given id.

impl<R: Reader> RpcStoreSchema<R>

pub fn iter_objects_of_type<'a>( &'a self, type_filter: &'a TypeFilter, ) -> Result<Iter<'a, Key, U64Varint>, Error>

Iterate over every live object whose Move type matches type_filter, regardless of owner. See TypeFilter for the matching contract.

TypeFilter encodes to the same leading bytes that Key uses for its type_ component, so the filter value passes through directly as the prefix.

impl<R: Reader> RpcStoreSchema<R>

pub fn get_object_version_at_checkpoint( &self, id: ObjectID, checkpoint: u64, ) -> Result<Option<SequenceNumber>, Error>

Resolve the version an object had as of checkpoint.

The caller is responsible for confirming checkpoint is within this index’s available range; this method assumes it is.

Two steps:

1. Floor scan — the greatest entry at or before checkpoint is the version live then: the row written at the most recent checkpoint, at or before the queried one, in which the object changed (or a restore/backfill floor row).
2. Restore fallback — if no entry is at or before checkpoint, the object’s earliest entry is the only candidate, and it lies after checkpoint. If that row is a restore floor (from_restore set), the object predates the available window and was live then at that version. Otherwise it is a later change or creation, so the object did not exist as of checkpoint.

Returns Ok(None) when the object did not exist as of checkpoint (or its history there has been pruned). The returned version may point at a tombstone row in super::objects; use get_object_at_checkpoint to collapse that to “no live object”.

pub fn get_object_at_checkpoint( &self, id: ObjectID, checkpoint: u64, ) -> Result<Option<Object>, Error>

Resolve the live object as of checkpoint, composing get_object_version_at_checkpoint with the version-keyed super::objects lookup.

Returns Ok(None) when the object did not exist as of checkpoint, or was deleted or wrapped at or before it (the resolved version points at a tombstone row).

pub fn iter_object_versions_by_checkpoint( &self, id: ObjectID, ) -> Result<Iter<'_, Key, Value>, Error>

Iterate every (checkpoint, version) recorded for id, in ascending checkpoint order.

pub fn get_latest_object_version( &self, id: ObjectID, ) -> Result<Option<SequenceNumber>, Error>

Resolve the latest version recorded for an object via this index: the version at its greatest-checkpoint row.

The checkpoint-unbounded counterpart to get_object_version_at_checkpoint: a reverse prefix scan takes the object’s highest-checkpoint row, whose version is the one live at the tip (a restore floor for an object that never changed in the window is itself that row). It agrees with the objects-CF reverse scan that backs get_object, since an object’s version increases monotonically with the checkpoints it changes in; this is offered as a convenience for callers already working through the checkpoint index.

The returned version may point at a tombstone row in super::objects (the object was deleted or wrapped and the removal has not yet been pruned). Returns Ok(None) when id has no row (it never existed, or its history has been fully pruned).

impl<R: Reader> RpcStoreSchema<R>

pub fn get_object_by_key( &self, id: ObjectID, version: SequenceNumber, ) -> Result<Option<Object>, Error>

Look up a specific version of an object, returning the live object if and only if the row at (id, version) is a live version. Tombstone rows and missing rows both return None; callers that need to distinguish the two should use get_object_status_by_key.

For the “latest live version” of an object id, use get_object, which reverse-scans this CF for the greatest version.

pub fn get_object_status_by_key( &self, id: ObjectID, version: SequenceNumber, ) -> Result<Option<Status>, Error>

Look up a specific version of an object, returning the typed Status so callers can distinguish live versions from tombstones. Ok(None) means no row was written at (id, version).

pub fn get_object(&self, id: ObjectID) -> Result<Option<Object>, Error>

Look up the latest live version of an object by id.

A single reverse prefix scan takes the object’s greatest (id, version) row and decodes it, returning the live object or None if that row is a tombstone. This mirrors the validator perpetual store’s get_object (reverse scan, then collapse Deleted / Wrapped to None). Returns Ok(None) when the object has no recorded version.

impl<R: Reader> RpcStoreSchema<R>

pub fn get_package_storage_id( &self, original_id: ObjectID, version: u64, ) -> Result<Option<ObjectID>, Error>

Look up the on-chain storage id that holds a specific version of a package.

pub fn iter_package_versions( &self, original_id: ObjectID, ) -> Result<Iter<'_, Key, Value>, Error>

Iterate every version of the package originally published at original_id, in ascending version order.

pub fn get_package_at_checkpoint( &self, original_id: ObjectID, checkpoint: u64, ) -> Result<Option<(u64, ObjectID)>, Error>

Resolve the latest version of the package originally published at original_id that existed as of checkpoint, returning its (version, storage_id).

Walks every recorded version of the package — cheap, since even the most-upgraded mainnet packages have on the order of a hundred versions — and keeps the highest version whose publish checkpoint is at or before checkpoint. Restore-floor rows (no recorded publish checkpoint) count as having always existed, since they predate the available window.

Returns Ok(None) when no version of the package existed as of checkpoint (it was first published later, or the package is unknown to this store).

impl<R: Reader> RpcStoreSchema<R>

pub fn get_pruning_watermarks(&self) -> Result<Option<Watermarks>, Error>

Read the persisted pruning watermarks from disk.

pub fn set_pruning_floor(&self, tx_seq_lo: u64)

Update the tx_seq floor used by the bitmap CFs’ compaction filters.

Callers that advance pruning should:

1. Stage a write to the pruning_watermark CF via store.
2. Commit the batch so the new watermarks are durable.
3. Call this method with the new tx_seq_lo so the in-memory floor matches what’s on disk.

pub fn refresh_pruning_atomics(&self) -> Result<(), Error>

Load the persisted pruning watermarks from disk into the in-memory bitmap floor.

Call once on startup so the bitmap compaction filters see the persisted floor instead of starting at zero (where they’d prune nothing).

impl<R: Reader> RpcStoreSchema<R>

pub fn get_transaction_bitmap( &self, dimension_key: Vec<u8>, bucket: u64, ) -> Result<Option<RoaringBitmap>, Error>

Look up the bitmap for (dimension_key, bucket) and return it deserialized.

pub fn iter_transaction_bitmap_buckets( &self, dimension_key: Vec<u8>, ) -> Result<Iter<'_, Key, Value>, Error>

Iterate every bucket recorded against dimension_key, in ascending bucket order.

impl<R: Reader> RpcStoreSchema<R>

pub fn get_transaction( &self, tx_seq: u64, ) -> Result<Option<(TransactionData, Vec<GenericSignature>)>, Error>

Look up the transaction data and signatures at the given assigned tx_seq.

Callers resolving from a TransactionDigest should first translate through tx_seq_by_digest.

impl<R: Reader> RpcStoreSchema<R>

pub fn get_tx_metadata_by_seq( &self, tx_seq: u64, ) -> Result<Option<Metadata>, Error>

Look up the metadata for the transaction at the given assigned tx_seq.

pub fn iter_tx_seq_digests( &self, from: u64, to_exclusive: u64, ) -> Result<impl Iterator<Item = Result<(u64, TransactionDigest), Error>> + '_, Error>

Iterate (tx_seq, digest) pairs over [from, to_exclusive), decoding only the digest from each row.

The pruner uses this to unindex tx_seq_by_digest for a pruned range. Iterating the table seeks straight to the first present row and visits only rows that exist, so a sparse range — or a floor of 0 when the lower bound is unknown — costs work proportional to the rows actually present, not to the width of the tx_seq interval.

impl<R: Reader> RpcStoreSchema<R>

pub fn get_tx_seq_by_digest( &self, digest: &TransactionDigest, ) -> Result<Option<u64>, Error>

Look up the sequence number of the transaction identified by digest.

Trait Implementations

impl Schema for RpcStoreSchema

fn cfs(opts: &CfOptionsResolver) -> Vec<CfDescriptor>

The column families this schema requires.

fn open(db: &Db) -> Result<Self, OpenError>

Construct the schema struct against db.

impl SchemaAtSnapshot for RpcStoreSchema

type At = RpcStoreSchema<Snapshot>

The projected schema body — typically MySchema<Snapshot> when the schema is parameterized by a Reader.

fn at(&self, snap: &Snapshot) -> Self::At

Re-bind this schema at snap.