Struct State 

pub struct State { /* private fields */ }

The rollup state.

Implementations

impl State

pub async fn load( data_path: &Path, termination_ask: Sender<ApplyBlockError>, ) -> Result<Self, StateInitializationError>

Loads the state from the data directory.

pub async fn apply_block( &self, block: ProvenBlock, ) -> 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 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 sync_nullifiers( &self, prefix_len: u32, nullifier_prefixes: Vec<u32>, block_range: RangeInclusive<BlockNumber>, ) -> Result<(Vec<NullifierInfo>, BlockNumber), DatabaseError>

pub async fn check_nullifiers(&self, nullifiers: &[Nullifier]) -> Vec<SmtProof>

Generates membership proofs for each one of the nullifiers against the latest nullifier tree.

Note: these proofs are invalidated once the nullifier tree is modified, i.e. on a new block.

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_current_blockchain_data( &self, block_num: Option<BlockNumber>, ) -> Result<Option<(BlockHeader, MmrPeaks)>, GetCurrentBlockchainDataError>

If the input block number is the current chain tip, None is returned. Otherwise, gets the current chain tip’s block header with its corresponding MMR peaks.

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 sync_state( &self, block_num: BlockNumber, account_ids: Vec<AccountId>, note_tags: Vec<u32>, ) -> Result<(StateSyncUpdate, MmrDelta), StateSyncError>

Loads data to synchronize a client.

The client’s request contains a list of note tags, this method will return the first block with a matching tag, or the chain tip. All the other values are filtered based on this block range.

Arguments

• block_num: The last block known by the client, updates start from the next block.
• account_ids: Include the account’s commitment if their last change was in the result’s block range.
• note_tags: The tags the client is interested in, result is restricted to the first block with any matches tags.

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

Loads data to synchronize a client’s notes.

The client’s request contains a list of tags, this method will return the first block with a matching tag, or the chain tip. All the other values are filter based on this block range.

Arguments

• note_tags: The tags the client is interested in, resulting notes are restricted to the first block containing a matching note.
• block_range: The range of blocks from which to synchronize notes.

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 get_account_details( &self, id: AccountId, ) -> Result<AccountInfo, DatabaseError>

Returns details for public (on-chain) account.

pub async fn get_network_account_details_by_id( &self, account_id: AccountId, ) -> Result<Option<AccountInfo>, DatabaseError>

Returns details for public (on-chain) network accounts by full account ID.

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

Returns network account IDs within the specified block range (based on account creation block).

The function may return fewer accounts than exist in the range if the result would exceed MAX_RESPONSE_PAYLOAD_BYTES / AccountId::SERIALIZED_SIZE rows. In this case, the result is truncated at a block boundary to ensure all accounts from included blocks are returned.

The response includes the last block number that was fully included in the result.

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

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.

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 latest_block_num(&self) -> BlockNumber

Returns the latest block number.

pub async fn analyze_table_sizes(&self) -> Result<(), DatabaseError>

Emits metrics for each database table’s size.

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 get_unconsumed_network_notes_for_account( &self, account_id: AccountId, block_num: BlockNumber, page: Page, ) -> Result<(Vec<NoteRecord>, Page), DatabaseError>

Returns the network notes for an account that are unconsumed by a specified block number, along with the next pagination token.

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

Returns the script for a note by its root.

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 get_vault_asset_witnesses( &self, account_id: AccountId, block_num: BlockNumber, vault_keys: BTreeSet<AssetVaultKey>, ) -> Result<Vec<AssetWitness>, WitnessError>

Returns vault asset witnesses for the specified account and block number.

pub async fn get_storage_map_witness( &self, account_id: AccountId, slot_name: &StorageSlotName, block_num: BlockNumber, raw_key: Word, ) -> Result<StorageMapWitness, WitnessError>

Returns a storage map witness for the specified account and storage entry at the block number.

Note that the raw_key is the raw, user-provided key that needs to be hashed in order to get the actual key into the storage map.