Struct State 

pub struct State { /* private fields */ }

The rollup state.

Implementations

impl State

pub async fn get_account( &self, account_request: AccountRequest, ) -> Result<AccountResponse, GetAccountError>

Returns an account witness and optionally account details at a specific block.

The witness is a Merkle proof of inclusion in the account tree, proving the account’s state commitment. If details is requested, the method also returns the account’s code, vault assets, and storage data. Account details are only available for public accounts.

If block_num is provided, returns the state at that historical block; otherwise, returns the latest state. Note that historical states are only available for recent blocks close to the chain tip.

impl State

pub fn block_subscription( self: &Arc<Self>, from: BlockNumber, ) -> BlockSubscriptionStream

Streams committed blocks starting from from, replaying historical blocks first and then following live commits.

pub fn proof_subscription( self: &Arc<Self>, from: BlockNumber, ) -> ProofSubscriptionStream

Streams block proofs starting from from, replaying historical proofs first and then following newly proven blocks.

impl State

pub async fn apply_block_with_proving_inputs( &self, ordered_batches: OrderedBatches, block_inputs: BlockInputs, signed_block: SignedBlock, ) -> Result<(), ApplyBlockWithProvingInputsError>

Saves proving inputs for a signed block and applies it to the state.

Used by the in-process block producer after it has built and signed a block.

pub async fn apply_block( &self, signed_block: SignedBlock, ) -> Result<(), ApplyBlockError>

Apply changes of a new block to the DB and in-memory data structures.

Note on state consistency

The server contains in-memory representations of the existing trees, the in-memory representation must be kept consistent with the committed data, this is necessary so to provide consistent results for all endpoints. In order to achieve consistency, the following steps are used:

• the request data is validated, prior to starting any modifications.
• block is being saved into the store in parallel with updating the DB, but before committing. This block is considered as candidate and not yet available for reading because the latest block pointer is not updated yet.
• a transaction is open in the DB and the writes are started.
• while the transaction is not committed, concurrent reads are allowed, both the DB and the in-memory representations, which are consistent at this stage.
• prior to committing the changes to the DB, an exclusive lock to the in-memory data is acquired, preventing concurrent reads to the in-memory data, since that will be out-of-sync w.r.t. the DB.
• the DB transaction is committed, and requests that read only from the DB can proceed to use the fresh data.
• the in-memory structures are updated, including the latest block pointer and the lock is released.

pub async fn save_proving_inputs( &self, block_num: BlockNumber, proving_inputs: &BlockProofRequest, ) -> Result<()>

Saves the proving inputs for the given block to the block store.

impl State

pub async fn apply_proof( &self, block_num: BlockNumber, proof_bytes: Vec<u8>, ) -> Result<()>

Saves a block proof, advances the proven-in-sequence tip, and notifies replica subscribers.

impl State

pub fn bootstrap(genesis: GenesisBlock, data_directory: &Path) -> Result<()>

Bootstraps the store state, creating the database state and inserting the genesis block data.

impl State

pub fn spawn_disk_monitor(&self) -> JoinHandle<()>

Spawns a background task that periodically records the on-disk size of every store data path as OTel span attributes.

impl State

pub async fn sync_transactions( &self, account_ids: Vec<AccountId>, block_range: RangeInclusive<BlockNumber>, ) -> Result<(BlockNumber, Vec<TransactionRecord>), DatabaseError>

Returns the complete transaction records for the specified accounts within the specified block range, including state commitments and note IDs.

pub async fn sync_chain_mmr( &self, block_range: RangeInclusive<BlockNumber>, ) -> Result<(MmrDelta, BlockHeader, Signature), StateSyncError>

Returns the chain MMR delta and the block_to block header for the specified block range.

pub async fn sync_notes( &self, note_tags: Vec<u32>, block_range: RangeInclusive<BlockNumber>, ) -> Result<(Vec<(NoteSyncUpdate, MmrProof)>, BlockNumber), NoteSyncError>

Loads data to synchronize a client’s notes.

Returns as many blocks with matching notes as fit within the response payload limit (MAX_RESPONSE_PAYLOAD_BYTES). Each block includes its header and MMR proof at forest block_range.end() + 1.

Also returns the last block number checked. If this equals block_range.end(), the sync is complete.

pub async fn sync_nullifiers( &self, prefix_len: u32, nullifier_prefixes: Vec<u32>, block_range: RangeInclusive<BlockNumber>, ) -> Result<(Vec<NullifierInfo>, BlockNumber), DatabaseError>

pub async fn sync_account_vault( &self, account_id: AccountId, block_range: RangeInclusive<BlockNumber>, ) -> Result<(BlockNumber, Vec<AccountVaultValue>), DatabaseError>

Returns account vault updates for specified account within a block range.

pub async fn sync_account_storage_maps( &self, account_id: AccountId, block_range: RangeInclusive<BlockNumber>, ) -> Result<StorageMapValuesPage, DatabaseError>

Returns storage map values for syncing within a block range.

impl State

pub async fn load( data_path: &Path, storage_options: StorageOptions, ) -> Result<Self, StateInitializationError>

Loads the state from the data directory.

The loaded state owns all store data structures and exposes subscription methods for sequencer and replica tasks.

pub async fn load_with_database_options( data_path: &Path, storage_options: StorageOptions, database_options: DatabaseOptions, ) -> Result<Self, StateInitializationError>

Loads the state from the data directory using explicit database options.

The loaded state owns all store data structures and exposes subscription methods for sequencer and replica tasks.

pub fn subscribe_committed_tip(&self) -> Receiver<BlockNumber>

Returns a watch receiver that wakes every time a new block is committed.

pub async fn load_proving_inputs( &self, block_num: BlockNumber, ) -> Result<Option<Vec<u8>>>

Loads serialized block proving inputs from the block store.

pub async fn get_block_header( &self, block_num: Option<BlockNumber>, include_mmr_proof: bool, ) -> Result<(Option<BlockHeader>, Option<MmrProof>), GetBlockHeaderError>

Queries a BlockHeader from the database, and returns it alongside its inclusion proof.

If None is given as the value of block_num, the data for the latest BlockHeader is returned.

pub async fn get_notes_by_id( &self, note_ids: Vec<NoteId>, ) -> Result<Vec<NoteRecord>, DatabaseError>

Queries a list of notes from the database.

If the provided list of NoteId given is empty or no note matches the provided NoteId an empty list is returned.

pub async fn get_batch_inputs( &self, tx_reference_blocks: BTreeSet<BlockNumber>, unauthenticated_note_commitments: BTreeSet<Word>, ) -> Result<BatchInputs, GetBatchInputsError>

Fetches the inputs for a transaction batch from the database.

Inputs

The function takes as input:

• The tx reference blocks are the set of blocks referenced by transactions in the batch.
• The unauthenticated note commitments are the set of commitments of unauthenticated notes consumed by all transactions in the batch. For these notes, we attempt to find inclusion proofs. Not all notes will exist in the DB necessarily, as some notes can be created and consumed within the same batch.

Outputs

The function will return:

• A block inclusion proof for all tx reference blocks and for all blocks which are referenced by a note inclusion proof.
• Note inclusion proofs for all notes that were found in the DB.
• The block header that the batch should reference, i.e. the latest known block.

pub async fn get_block_inputs( &self, account_ids: Vec<AccountId>, nullifiers: Vec<Nullifier>, unauthenticated_note_commitments: BTreeSet<Word>, reference_blocks: BTreeSet<BlockNumber>, ) -> Result<BlockInputs, GetBlockInputsError>

Returns data needed by the block producer to construct and prove the next block.

pub async fn get_transaction_inputs( &self, account_id: AccountId, nullifiers: &[Nullifier], unauthenticated_note_commitments: Vec<Word>, ) -> Result<TransactionInputs, DatabaseError>

Returns data needed by the block producer to verify transactions validity.

pub async fn filter_network_accounts( &self, account_ids: &[AccountId], ) -> Result<HashSet<AccountId>, DatabaseError>

Filters account_ids down to the subset classified as network accounts.

pub async fn chain_tip(&self, finality: Finality) -> BlockNumber

Returns the effective chain tip for the given finality level.

• Finality::Committed: returns the latest committed block number (from in-memory MMR).
• Finality::Proven: returns the latest proven-in-sequence block number (cached via watch channel, updated by the proof scheduler).

pub async fn load_block( &self, block_num: BlockNumber, ) -> Result<Option<Vec<u8>>, DatabaseError>

Loads a block from the block store. Return Ok(None) if the block is not found.

pub async fn load_proof( &self, block_num: BlockNumber, ) -> Result<Option<Vec<u8>>, DatabaseError>

Loads a block proof from the block store. Returns Ok(None) if the proof is not found.

pub async fn get_note_script_by_root( &self, root: Word, ) -> Result<Option<NoteScript>, DatabaseError>

Returns the script for a note by its root.