Struct NoteScreener 

pub struct NoteScreener<AUTH> { /* private fields */ }

Provides functionality for testing whether a note is relevant to the client or not.

Here, relevance is based on whether the note is able to be consumed by an account that is tracked in the provided store. This can be derived in a number of ways, such as looking at the combination of script root and note inputs. For example, a P2ID note is relevant for a specific account ID if this ID is its first note input.

Implementations

impl<AUTH> NoteScreener<AUTH>

where AUTH: TransactionAuthenticator + Sync,

pub fn new( store: Arc<dyn Store>, authenticator: Option<Arc<AUTH>>, ) -> NoteScreener<AUTH>

pub fn with_transaction_args( self, tx_args: TransactionArgs, ) -> NoteScreener<AUTH>

Sets the transaction arguments to use when checking note consumability. If not set, a default TransactionArgs with an empty advice map is used.

pub async fn can_consume( &self, note: &Note, ) -> Result<Vec<(AccountId, NoteConsumptionStatus)>, NoteScreenerError>

Checks whether the provided note could be consumed by any of the accounts tracked by this screener. Convenience wrapper around Self::can_consume_batch for a single note.

Returns the NoteConsumptionStatus for each account that could consume the note.

pub async fn can_consume_batch( &self, notes: &[Note], ) -> Result<BTreeMap<NoteId, Vec<(AccountId, NoteConsumptionStatus)>>, NoteScreenerError>

Checks whether the provided notes could be consumed by any of the accounts tracked by this screener, by executing a transaction for each note-account pair.

Returns a map from NoteId to a list of (AccountId, NoteConsumptionStatus) pairs. Notes that are permanently unconsumable by all accounts are not included in the result.

pub async fn check_notes_consumability( &self, account_id: AccountId, notes: Vec<Note>, ) -> Result<NoteConsumptionInfo, NoteScreenerError>

Checks whether the provided notes could be consumed by a specific account by attempting to execute them together in a transaction. Notes that fail are progressively removed until a maximal set of successfully consumable notes is found.

Returns a NoteConsumptionInfo splitting notes into those that succeeded and those that failed.

Trait Implementations

impl<AUTH> Clone for NoteScreener<AUTH>

where AUTH: Clone,

fn clone(&self) -> NoteScreener<AUTH>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<AUTH> OnNoteReceived for NoteScreener<AUTH>

where AUTH: TransactionAuthenticator + Sync,

fn on_note_received<'life0, 'async_trait>( &'life0 self, committed_note: CommittedNote, public_note: Option<InputNoteRecord>, ) -> Pin<Box<dyn Future<Output = Result<NoteUpdateAction, ClientError>> + 'async_trait>>

where 'life0: 'async_trait, NoteScreener<AUTH>: 'async_trait,

Default implementation of the OnNoteReceived callback. It queries the store for the committed note to check if it’s relevant. If the note wasn’t being tracked but it came in the sync response it may be a new public note, in that case we use the NoteScreener to check its relevance.