Struct StateSync 

pub struct StateSync { /* private fields */ }

The state sync component encompasses the client’s sync logic. It is then used to request updates from the node and apply them to the relevant elements. The updates are then returned and can be applied to the store to persist the changes.

Implementations

impl StateSync

pub fn new( rpc_api: Arc<dyn NodeRpcClient>, note_screener: Arc<dyn OnNoteReceived>, tx_discard_delta: Option<u32>, ) -> StateSync

Creates a new instance of the state sync component.

The nullifiers sync is enabled by default. To disable it, see Self::disable_nullifier_sync.

Arguments

• rpc_api - The RPC client used to communicate with the node.
• note_screener - The note screener used to check the relevance of notes.
• tx_discard_delta - Number of blocks after which pending transactions are discarded.

pub fn disable_nullifier_sync(&mut self)

Disables the nullifier sync.

When disabled, the component will not query the node for new nullifiers after each sync step. This is useful for clients that don’t need to track note consumption, such as faucets.

pub fn enable_nullifier_sync(&mut self)

Enables the nullifier sync.

pub async fn sync_state( &self, current_partial_mmr: &mut PartialMmr, input: StateSyncInput, ) -> Result<StateSyncUpdate, ClientError>

Syncs the state of the client with the chain tip of the node, returning the updates that should be applied to the store.

Use Client::build_sync_input() to build the default input, or assemble it manually for custom sync. The current_partial_mmr is taken by mutable reference so callers can keep it in memory across syncs.

During the sync process, the following steps are performed:

1. A request is sent to the node to get the state updates. This request includes tracked account IDs and the tags of notes that might have changed or that might be of interest to the client.
2. A response is received with the current state of the network. The response includes information about new and committed notes, updated accounts, and committed transactions.
3. Tracked public accounts are updated and private accounts are validated against the node state.
4. Tracked notes are updated with their new states. Notes might be committed or nullified during the sync processing.
5. New notes are checked, and only relevant ones are stored. Relevance is determined by the OnNoteReceived callback.
6. Transactions are updated with their new states. Transactions might be committed or discarded.
7. The MMR is updated with the new peaks and authentication nodes.

Trait Implementations

impl Clone for StateSync

fn clone(&self) -> StateSync

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.