Struct zebra_consensus::redpallas::Verifier

pub struct Verifier {
    batch: Verifier<SpendAuth, Binding>,
    tx: Sender<Option<Result<(), Error>>>,
}

RedPallas signature verifier service

Fields

batch: Verifier<SpendAuth, Binding>

A batch verifier for RedPallas signatures.

tx: Sender<Option<Result<(), Error>>>

A channel for broadcasting the result of a batch to the futures for each batch item.

Each batch gets a newly created channel, so there is only ever one result sent per channel. Tokio doesn’t have a oneshot multi-consumer channel, so we use a watch channel.

Implementations

impl Verifier

fn take( &mut self, ) -> (Verifier<SpendAuth, Binding>, Sender<Option<Result<(), Error>>>)

Returns the batch verifier and channel sender from self, replacing them with a new empty batch.

fn verify( batch: Verifier<SpendAuth, Binding>, tx: Sender<Option<Result<(), Error>>>, )

Synchronously process the batch, and send the result using the channel sender. This function blocks until the batch is completed.

fn flush_blocking(&mut self)

Flush the batch using a thread pool, and return the result via the channel. This returns immediately, usually before the batch is completed.

async fn flush_spawning( batch: Verifier<SpendAuth, Binding>, tx: Sender<Option<Result<(), Error>>>, )

Flush the batch using a thread pool, and return the result via the channel. This function returns a future that becomes ready when the batch is completed.

async fn verify_single_spawning(item: Item) -> Result<(), BoxError>

Verify a single item using a thread pool, and return the result.

Trait Implementations

impl Default for Verifier

fn default() -> Self

Returns the “default value” for a type.

impl Drop for Verifier

fn drop(&mut self)

Executes the destructor for this type.

impl Service<BatchControl<Item<SpendAuth, Binding>>> for Verifier

type Response = ()

Responses given by the service.

type Error = Box<dyn Error + Sync + Send>

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<(), Box<dyn Error + Sync + Send>>> + Send>>

The future response value.

fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, req: BatchControl<Item>) -> Self::Future

Process the request and return the response asynchronously.