Struct NoteConsumptionChecker 

pub struct NoteConsumptionChecker<'a, STORE, AUTH>(/* private fields */);

This struct performs input notes check against provided target account.

The check is performed using the NoteConsumptionChecker::check_notes_consumability procedure. Essentially runs the transaction to make sure that provided input notes could be consumed by the account.

Implementations

impl<'a, STORE, AUTH> NoteConsumptionChecker<'a, STORE, AUTH>

where STORE: DataStore + Sync, AUTH: TransactionAuthenticator + Sync,

pub fn new(tx_executor: &'a TransactionExecutor<'a, 'a, STORE, AUTH>) -> Self

Creates a new NoteConsumptionChecker instance with the given transaction executor.

pub async fn check_notes_consumability( &self, target_account_id: AccountId, block_ref: BlockNumber, notes: Vec<Note>, tx_args: TransactionArgs, ) -> Result<NoteConsumptionInfo, NoteCheckerError>

Checks whether some set of the provided input notes could be consumed by the provided account by executing the transaction with varying combination of notes.

This function attempts to find the maximum set of notes that can be successfully executed together by the target account.

Because of the runtime complexity involved in this function, a limited range of MAX_NUM_CHECKER_NOTES input notes is allowed.

If some notes succeed and others fail, the failed notes are removed from the candidate set and the remaining notes (successful + unattempted) are retried in the next iteration. This process continues until either all remaining notes succeed or no notes can be successfully executed

For example, given notes A, B, C, D, E, the execution flow would be as follows:

• Try [A, B, C, D, E] → A, B succeed, C fails → Remove C, try again.
• Try [A, B, D, E] → A, B, D succeed, E fails → Remove E, try again.
• Try [A, B, D] → All succeed → Return successful=[A, B, D], failed=[C, E].

If a failure occurs at the epilogue phase of the transaction execution, the relevant set of otherwise-successful notes are retried in various combinations in an attempt to find a combination that passes the epilogue phase successfully.

Returns a list of successfully consumed notes and a list of failed notes.

pub async fn can_consume( &self, target_account_id: AccountId, block_ref: BlockNumber, note: InputNote, tx_args: TransactionArgs, ) -> Result<NoteConsumptionStatus, NoteCheckerError>

Checks whether the provided input note could be consumed by the provided account by executing a transaction at the specified block height.

This function takes into account the possibility that the signatures may not be loaded into the transaction context and returns the NoteConsumptionStatus result accordingly.

This function first applies the static analysis of the provided note, and if it doesn’t reveal any errors next it tries to execute the transaction. Based on the execution result, it either returns a NoteCheckerError or the NoteConsumptionStatus: depending on whether the execution succeeded, failed in the prologue, during the note execution process or in the epilogue.