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,

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 find_verified_unmined_tx( req: &Request, mempool: Option<Timeout<Mempool>>, state: Timeout<ZS>, ) -> Option<Result<VerifiedUnminedTx, TransactionError>>

Attempts to find a transaction in the mempool by its transaction hash and checks that all of its dependencies are available in the block or in the state. Waits for UTXOs being spent by the given transaction to arrive in the state if they’re not found elsewhere.

Returns Some(Ok(VerifiedUnminedTx)) if successful, None if the transaction id was not found in the mempool, or Some(Err(TransparentInputNotFound)) if the transaction was found, but some of its dependencies were not found in the block or state after a timeout.

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

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

Looks up UTXOs that are being spent by the given transaction in the state or waits for them to be added to the mempool for Mempool requests.

Returns a triple containing:

• OutPoint -> Utxo map,
• vec of Outputs in the same order as the matching inputs in the tx,
• vec of Outpoints spent by a mempool tx that were not found in the best chain’s utxo set.

pub fn check_maturity_height( network: &Network, 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>>, ) -> 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>, ) -> 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, 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, ) -> AsyncChecks

Verifies a transaction’s Orchard shielded data.

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.