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 with_note_observer(self, observer: Arc<dyn NoteObserver>) -> StateSync

Attaches a NoteObserver to this sync component. Observers run in attachment order before the screener verdict; failures are logged (tagged with NoteObserver::name) and never abort sync.

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; it is only modified once every check has passed.

During the sync process, the following steps are performed:

1. Fetch sync data from the node (MMR delta, note inclusions, transactions).
2. Update account states (fetch updated public accounts, flag mismatched private ones).
3. Screen note inclusions via the configured OnNoteReceived callback.
4. Process transaction inclusions (commit local txs, record external consumers, discard stale/expired txs, commit output notes).
5. Recover the public notes a tracked account consumed but the client never tracked.
6. Detect consumed notes via nullifier sync (optional, see Self::disable_nullifier_sync).
7. Advance the partial MMR to the chain tip and track the screened blocks that still hold an unspent note.

Steps 1-2 are Self::fetch_state, 3-5 Self::derive_state_updates, 6 Self::fetch_nullifiers and 7 Self::build_update; each can be driven separately.

pub async fn fetch_state( &self, block_from: BlockNumber, input: StateSyncInput, ) -> Result<ChainSyncData, ClientError>

Fetches the node’s view of everything that changed since block_from: the MMR delta, the note inclusions, the transactions, and the account states.

Every node call that does not depend on note screening happens here, so a caller can run this concurrently with another sync’s fetch. Interpreting the response is Self::derive_state_updates’s, and the nullifier check Self::fetch_nullifiers’s. Both run afterwards so a caller syncing more than one source can write the other source first, and check nullifiers once across all of them.

pub async fn derive_state_updates( &self, chain_sync_data: &mut ChainSyncData, ) -> Result<(), ClientError>

Turns the node’s raw response into note and transaction updates.

Discards the local transactions the node superseded, screens the received notes for relevance, applies the transaction inclusions, and recovers the public notes the tracked accounts consumed, fetching those by id.

pub fn build_update( chain_sync_data: ChainSyncData, partial_mmr: &mut PartialMmr, ) -> Result<StateSyncUpdate, ClientError>

Verifies the fetched chain data against partial_mmr and turns it into the update to apply to the store.

It applies the node’s delta, checks the resulting peaks against the chain tip header’s chain commitment, and tracks the screened note blocks that still hold an unspent note.

pub async fn fetch_nullifiers( &self, chain_sync_data: &mut ChainSyncData, ) -> Result<(), ClientError>

Checks the node for nullifiers of every note chain_sync_data could have consumed.

The query covers every note the tracker holds, including any the caller added from another sync path — so a transport-delivered note consumed within one sync is reported as consumed by that same sync.

No-op when the nullifier sync is disabled (see Self::disable_nullifier_sync) or when the node reported no progress, since there is no block range to query.

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.