Struct Verifier 

pub struct Verifier<ZS, Mempool> {
    network: Network,
    state: Timeout<ZS>,
    mempool: Option<Timeout<Mempool>>,
    script_verifier: Verifier,
    mempool_setup_rx: Receiver<Mempool>,
}

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>

mempool: Option<Timeout<Mempool>>

script_verifier: Verifier

mempool_setup_rx: Receiver<Mempool>

Implementations

impl<ZS, Mempool> Verifier<ZS, Mempool>

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

pub fn new( network: &Network, state: ZS, mempool_setup_rx: Receiver<Mempool>, ) -> Self

Create a new transaction verifier.

impl<ZS, Mempool> Verifier<ZS, Mempool>

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

fn verify_block( &self, req: Request, ) -> Pin<Box<dyn Future<Output = Result<Response, TransactionError>> + Send + 'static>>

Verifies a transaction in block context.

fn verify_mempool( &self, req: Request, ) -> Pin<Box<dyn Future<Output = Result<Response, TransactionError>> + Send + 'static>>

Verifies a transaction in mempool context.

fn check_structure_and_network_rules( tx: &Transaction, height: Height, network: &Network, ) -> Result<(), TransactionError>

Performs basic structural validation and Orchard-related network upgrade rules.

fn check_transaction_invariants( tx: &Transaction, height: Height, network: &Network, ) -> Result<(), TransactionError>

Validates transaction invariants.

async fn verify_mempool_lock_time( tx: &Transaction, height: Height, state: Timeout<ZS>, ) -> Result<(), TransactionError>

Validates mempool lock-time consensus rules.

Queries state only for time-based lock times.

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 block_spent_utxos( tx: Arc<Transaction>, known_utxos: Arc<HashMap<OutPoint, OrderedUtxo>>, state: Timeout<ZS>, ) -> Result<(HashMap<OutPoint, Utxo>, Vec<Output>), TransactionError>

Looks up UTXOs spent by tx from the best chain state, also checking known_utxos for UTXOs from earlier transactions in the same block.

Returns an OutPoint -> Utxo map and a vec of Outputs in the same order as the matching inputs in tx.

async fn mempool_spent_utxos( tx: Arc<Transaction>, height: Height, state: Timeout<ZS>, mempool: Option<Timeout<Mempool>>, ) -> Result<(HashMap<OutPoint, Utxo>, Vec<Output>, Vec<OutPoint>), TransactionError>

Looks up UTXOs spent by a mempool tx, first querying the best chain state and then the mempool for inputs whose outputs are not present in the best chain.

height is the next block height, used to construct Utxo values for outputs sourced from the mempool.

Returns an OutPoint -> Utxo map, a vec of Outputs in the same order as the matching inputs in tx, and a vec of OutPoints that were sourced from the mempool rather than the best chain.

fn check_maturity_height( tx: Arc<Transaction>, height: Height, network: &Network, spent_utxos: &HashMap<OutPoint, Utxo>, ) -> Result<(), TransactionError>

Checks that every transparent coinbase output spent by tx has matured by height.

This check applies only to mempool transactions. Block transactions are checked during contextual validation in the state (see #2336).

Calls check::tx_transparent_coinbase_spends_maturity with an empty block_new_outputs map, since mempool transactions have no block context.

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

fn dispatch_version_verification( tx: &Transaction, nu: NetworkUpgrade, script_verifier: Verifier, cached_ffi_transaction: Arc<CachedFfiTransaction>, ) -> Result<AsyncChecks, TransactionError>

Dispatches version-specific async verification checks for tx.

nu is the network upgrade active at the transaction’s block height, pre-computed by the caller from req.upgrade(&network).

Returns TransactionError::WrongVersion for V1-V3 transactions, which are not supported by any network upgrade Zebra verifies.

fn verify_v4_transaction( tx: &Transaction, nu: NetworkUpgrade, script_verifier: Verifier, cached_ffi_transaction: Arc<CachedFfiTransaction>, joinsplit_data: &Option<JoinSplitData<Groth16Proof>>, ) -> 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 tx transaction to verify
• the nu network upgrade active at the transaction’s block height
• 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

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( tx: &Transaction, nu: NetworkUpgrade, script_verifier: Verifier, cached_ffi_transaction: Arc<CachedFfiTransaction>, ) -> 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 tx transaction to verify
• the nu network upgrade active at the transaction’s block height
• the script_verifier to use for verifying the transparent transfers
• the prepared cached_ffi_transaction used by the script verifier

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_v6_transaction( tx: &Transaction, nu: NetworkUpgrade, script_verifier: Verifier, cached_ffi_transaction: Arc<CachedFfiTransaction>, ) -> Result<AsyncChecks, TransactionError>

Verifies a V6 (NU6.3 / Ironwood) transaction’s shielded data.

Differs from Self::verify_v5_transaction in the Orchard verifier: a v6 Orchard bundle commits to the NU6.3 cross-address circuit, so it (and the Ironwood bundle) verify under the NU6.3 key, not the v5 fixed key.

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

Verifies that a V6 transaction is supported by network_upgrade.

V6 transactions are only valid from NU6.3 onward.

fn verify_transparent_inputs_and_outputs( tx: &Transaction, 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_bundle( bundle: Option<Bundle<Authorized, ZatBalance>>, sighash: &SigHash, ) -> AsyncChecks

Verifies a transaction’s Sapling shielded data.

fn verify_orchard_bundle( bundle: Option<Bundle<Authorized, ZatBalance>>, sighash: &SigHash, network_upgrade: NetworkUpgrade, ) -> AsyncChecks

Verifies a v5 transaction’s Orchard bundle.

A v5 Orchard bundle commits to the Orchard Action circuit of the block’s era, so the verifying key is selected by network_upgrade via primitives::halo2::orchard_v5_verifier_for: the historical insecure key before NU6.2, the fixed key from NU6.2 until NU6.3, and the NU6.3 key from NU6.3 onward. The Orchard-pool cross-address restriction applies to every Orchard Action from NU6.3 onward regardless of transaction version (ZIP 229), so a v5 bundle at NU6.3 uses the NU6.3 circuit — the same key as v6 Orchard and Ironwood bundles — not the fixed one.

fn verify_orchard_v6_bundle( bundle: Option<Bundle<Authorized, ZatBalance>>, sighash: &SigHash, ) -> AsyncChecks

Verifies a v6 transaction’s Orchard bundle.

A v6 Orchard bundle commits to the NU6.3 cross-address circuit, so it always verifies under the NU6.3 key (primitives::halo2::orchard_v6_verifier), independent of the block’s network upgrade (v6 transactions only exist from NU6.3 onward). The Ironwood bundle reuses the same verifier.

fn queue_orchard_bundle( select_verifier: impl FnOnce() -> &'static VerifierService, bundle: Option<Bundle<Authorized, ZatBalance>>, sighash: &SigHash, ) -> AsyncChecks

Queues an Orchard-shaped bundle’s single aggregated Halo2 proof against a verifier.

Consensus

The proof 𝜋 MUST be valid given a primary input (cv, rt^{Orchard}, nf, rk, cm_x, enableSpends, enableOutputs)

https://zips.z.cash/protocol/protocol.pdf#actiondesc

Unlike Sapling, Orchard shielded transactions have a single aggregated Halo2 proof per transaction, even with multiple Actions, so it is queued for verification only once instead of once per Action description. The choice of verifying key is the caller’s; see Self::verify_orchard_bundle and Self::verify_orchard_v6_bundle.

select_verifier is only invoked when a bundle is present, so a bundle-less transaction never forces the (lazily initialized) verifier services.

fn miner_fee( tx: &Transaction, spent_utxos: &HashMap<OutPoint, Utxo>, ) -> Result<Amount<NonNegative>, TransactionError>

Calculate the miner fee from the transaction’s value balance.

Trait Implementations

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

where ZS: Service<Request, Response = Response, Error = BoxError> + Send + Clone + 'static, ZS::Future: Send + 'static, Mempool: Service<Request, Response = Response, Error = BoxError> + Send + Clone + 'static, Mempool::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, Mempool> as Service<Request>>::Response, <Verifier<ZS, Mempool> 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.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.