Struct zebra_consensus::transaction::Verifier

pub struct Verifier<ZS> {
    network: Network,
    state: Timeout<ZS>,
    script_verifier: Verifier,
}

Asynchronous transaction verification.

Correctness

Transaction verification requests should be wrapped in a timeout, so that out-of-order and invalid requests do not hang indefinitely. See the router module documentation for details.

Fields

network: Network

state: Timeout<ZS>

script_verifier: Verifier

Implementations

impl<ZS> Verifier<ZS>

where ZS: Service<Request, Response = Response, Error = BoxError> + Send + Clone + 'static, ZS::Future: Send + 'static,

pub fn new(network: &Network, state: ZS) -> Self

Create a new transaction verifier.

impl<ZS> Verifier<ZS>

where ZS: Service<Request, Response = Response, Error = BoxError> + Send + Clone + 'static, ZS::Future: Send + 'static,

async fn mempool_best_chain_next_median_time_past( state: Timeout<ZS> ) -> Result<DateTime32, TransactionError>

Fetches the median-time-past of the next block after the best state tip.

This is used to verify that the lock times of mempool transactions can be included in any valid next block.

async fn spent_utxos( tx: Arc<Transaction>, known_utxos: Arc<HashMap<OutPoint, OrderedUtxo>>, is_mempool: bool, state: Timeout<ZS> ) -> Result<(HashMap<OutPoint, Utxo>, Vec<Output>), TransactionError>

Wait for the UTXOs that are being spent by the given transaction.

known_utxos are additional UTXOs known at the time of validation (i.e. from previous transactions in the block).

Returns a tuple with a OutPoint -> Utxo map, and a vector of Outputs in the same order as the matching inputs in the transaction.

pub fn check_maturity_height( request: &Request, spent_utxos: &HashMap<OutPoint, Utxo> ) -> Result<(), TransactionError>

Accepts request, a transaction verifier &Request, and spent_utxos, a HashMap of UTXOs in the chain that are spent by this transaction.

Gets the transaction, height, and known_utxos for the request and checks calls check::tx_transparent_coinbase_spends_maturity to verify that every transparent coinbase output spent by the transaction will have matured by height.

Returns Ok(()) if every transparent coinbase output spent by the transaction is mature and valid for the request height, or a TransactionError if the transaction spends transparent coinbase outputs that are immature and invalid for the request height.

fn verify_v4_transaction( request: &Request, network: &Network, script_verifier: Verifier, cached_ffi_transaction: Arc<CachedFfiTransaction>, joinsplit_data: &Option<JoinSplitData<Groth16Proof>>, sapling_shielded_data: &Option<ShieldedData<PerSpendAnchor>> ) -> Result<AsyncChecks, TransactionError>

Verify a V4 transaction.

Returns a set of asynchronous checks that must all succeed for the transaction to be considered valid. These checks include:

• transparent transfers
• sprout shielded data
• sapling shielded data

The parameters of this method are:

• the request to verify (that contains the transaction and other metadata, see Request for more information)
• the network to consider when verifying
• the script_verifier to use for verifying the transparent transfers
• the prepared cached_ffi_transaction used by the script verifier
• the Sprout joinsplit_data shielded data in the transaction
• the sapling_shielded_data in the transaction

fn verify_v4_transaction_network_upgrade( transaction: &Transaction, network_upgrade: NetworkUpgrade ) -> Result<(), TransactionError>

Verifies if a V4 transaction is supported by network_upgrade.

fn verify_v5_transaction( request: &Request, network: &Network, script_verifier: Verifier, cached_ffi_transaction: Arc<CachedFfiTransaction>, sapling_shielded_data: &Option<ShieldedData<SharedAnchor>>, orchard_shielded_data: &Option<ShieldedData> ) -> Result<AsyncChecks, TransactionError>

Verify a V5 transaction.

Returns a set of asynchronous checks that must all succeed for the transaction to be considered valid. These checks include:

• transaction support by the considered network upgrade (see Request::upgrade)
• transparent transfers
• sapling shielded data (TODO)
• orchard shielded data (TODO)

The parameters of this method are:

• the request to verify (that contains the transaction and other metadata, see Request for more information)
• the network to consider when verifying
• the script_verifier to use for verifying the transparent transfers
• the prepared cached_ffi_transaction used by the script verifier
• the sapling shielded data of the transaction, if any
• the orchard shielded data of the transaction, if any

fn verify_v5_transaction_network_upgrade( transaction: &Transaction, network_upgrade: NetworkUpgrade ) -> Result<(), TransactionError>

Verifies if a V5 transaction is supported by network_upgrade.

fn verify_transparent_inputs_and_outputs( request: &Request, network: &Network, script_verifier: Verifier, cached_ffi_transaction: Arc<CachedFfiTransaction> ) -> Result<AsyncChecks, TransactionError>

Verifies if a transaction’s transparent inputs are valid using the provided script_verifier and cached_ffi_transaction.

Returns script verification responses via the utxo_sender.

fn verify_sprout_shielded_data( joinsplit_data: &Option<JoinSplitData<Groth16Proof>>, shielded_sighash: &SigHash ) -> Result<AsyncChecks, TransactionError>

Verifies a transaction’s Sprout shielded join split data.

fn verify_sapling_shielded_data<A>( sapling_shielded_data: &Option<ShieldedData<A>>, shielded_sighash: &SigHash ) -> Result<AsyncChecks, TransactionError>

where A: AnchorVariant + Clone, Spend<PerSpendAnchor>: From<(Spend<A>, A::Shared)>,

Verifies a transaction’s Sapling shielded data.

fn verify_orchard_shielded_data( orchard_shielded_data: &Option<ShieldedData>, shielded_sighash: &SigHash ) -> Result<AsyncChecks, TransactionError>

Verifies a transaction’s Orchard shielded data.

Trait Implementations

impl<ZS: Clone> Clone for Verifier<ZS>

fn clone(&self) -> Verifier<ZS>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<ZS: Debug> Debug for Verifier<ZS>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<ZS> Service<Request> for Verifier<ZS>

where ZS: Service<Request, Response = Response, Error = BoxError> + Send + Clone + 'static, ZS::Future: Send + 'static,

type Response = Response

Responses given by the service.

type Error = TransactionError

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<<Verifier<ZS> as Service<Request>>::Response, <Verifier<ZS> as Service<Request>>::Error>> + 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: Request) -> Self::Future

Process the request and return the response asynchronously.