Enum Request

pub enum Request {
    Block {
        transaction_hash: Hash,
        transaction: Arc<Transaction>,
        known_outpoint_hashes: Arc<HashSet<Hash>>,
        known_utxos: Arc<HashMap<OutPoint, OrderedUtxo>>,
        height: Height,
        time: DateTime<Utc>,
    },
    Mempool {
        transaction: UnminedTx,
        height: Height,
    },
}

Specifies whether a transaction should be verified as part of a block or as part of the mempool.

Transaction verification has slightly different consensus rules, depending on whether the transaction is to be included in a block on in the mempool.

Variants

Block

Verify the supplied transaction as part of a block.

Fields

transaction_hash: Hash

The transaction hash.

transaction: Arc<Transaction>

The transaction itself.

known_outpoint_hashes: Arc<HashSet<Hash>>

Set of transaction hashes that create new transparent outputs.

known_utxos: Arc<HashMap<OutPoint, OrderedUtxo>>

Additional UTXOs which are known at the time of verification.

height: Height

The height of the block containing this transaction.

time: DateTime<Utc>

The time that the block was mined.

Mempool

Verify the supplied transaction as part of the mempool.

Mempool transactions do not have any additional UTXOs.

Note: coinbase transactions are invalid in the mempool

Fields

transaction: UnminedTx

The transaction itself.

height: Height

The height of the next block.

The next block is the first block that could possibly contain a mempool transaction.

Implementations

impl Request

pub fn transaction(&self) -> Arc<Transaction>

The transaction to verify that’s in this request.

pub fn mempool_transaction(&self) -> Option<UnminedTx>

The unverified mempool transaction, if this is a mempool request.

pub fn tx_id(&self) -> UnminedTxId

The unmined transaction ID for the transaction in this request.

pub fn tx_mined_id(&self) -> Hash

The mined transaction ID for the transaction in this request.

pub fn known_utxos(&self) -> Arc<HashMap<OutPoint, OrderedUtxo>>

The set of additional known unspent transaction outputs that’s in this request.

pub fn known_outpoint_hashes(&self) -> Arc<HashSet<Hash>>

The set of additional known transparent::OutPoints of unspent transaction outputs that’s in this request.

pub fn height(&self) -> Height

The height used to select the consensus rules for verifying this transaction.

pub fn block_time(&self) -> Option<DateTime<Utc>>

The block time used for lock time consensus rules validation.

pub fn upgrade(&self, network: &Network) -> NetworkUpgrade

The network upgrade to consider for the verification.

This is based on the block height from the request, and the supplied network.

pub fn is_mempool(&self) -> bool

Returns true if the request is a mempool request.

Trait Implementations

impl Clone for Request

fn clone(&self) -> Request

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Request

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

Formats the value using the given formatter.

impl PartialEq for Request

fn eq(&self, other: &Request) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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.

impl Eq for Request

impl StructuralPartialEq for Request