Struct State 

pub struct State { /* private fields */ }

The rollup state

Implementations

impl State

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

Loads the state from the db.

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 tag prefixes, 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

• 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_prefix( &self, id_prefix: u32, ) -> Result<Option<AccountInfo>, DatabaseError>

Returns details for public (on-chain) network accounts.

pub async fn get_account_proof( &self, account_request: AccountProofRequest, ) -> Result<AccountProofResponse, DatabaseError>

Returns the respective account proof with optional details, such as asset and storage entries.

Note: The block_num parameter in the request is currently ignored and will always return the current state. Historical block support will be implemented in a future update.

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 optimize_db(&self) -> Result<(), DatabaseError>

Runs database optimization.

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

Returns the unprocessed network notes, along with the next pagination token.

pub async fn get_unconsumed_network_notes_for_account( &self, network_account_id_prefix: NetworkAccountPrefix, 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.