Enum TransactionDataRequest 

pub enum TransactionDataRequest {
    GetStatus(TxId),
    Enhancement(TxId),
    TransactionsInvolvingAddress(TransactionsInvolvingAddress),
    GetSpendingTx(OutPoint),
}

A request for transaction data enhancement, spentness check, or discovery of spends from a given transparent address within a specific block range.

Variants

GetStatus(TxId)

Information about the chain’s view of a transaction is requested.

The caller evaluating this request on behalf of the wallet backend should respond to this request by determining the status of the specified transaction with respect to the main chain; if using lightwalletd for access to chain data, this may be obtained by interpreting the results of the GetTransaction RPC method. It should then call WalletWrite::set_transaction_status to provide the resulting transaction status information to the wallet backend.

Enhancement(TxId)

Transaction enhancement (download of complete raw transaction data) is requested.

The caller evaluating this request on behalf of the wallet backend should respond to this request by providing complete data for the specified transaction to wallet::decrypt_and_store_transaction; if using lightwalletd for access to chain state, this may be obtained via the GetTransaction RPC method. If no data is available for the specified transaction, this should be reported to the backend using WalletWrite::set_transaction_status. A TransactionDataRequest::Enhancement request subsumes any previously existing TransactionDataRequest::GetStatus request.

TransactionsInvolvingAddress(TransactionsInvolvingAddress)

Available on crate feature transparent-inputs only.

Information about transactions that receive or spend funds belonging to the specified transparent address is requested.

Fully transparent transactions, and transactions that do not contain either shielded inputs or shielded outputs belonging to the wallet, may not be discovered by the process of out-of-order chain scanning due to race conditions related to advancing the transparent address gap limit; as a consequence, the wallet must actively query to find transactions that spend such funds. Ideally we’d be able to query by [OutPoint] but this is not currently functionality that is supported by the light wallet server; for full-node wallets or other arrangements that allow privacy-preserving retrieval of individually identifying information such as backends that support private information retrieval (PIR) consider enabling the spend-index feature.

The caller evaluating this request on behalf of the wallet backend should respond to this request by detecting transactions involving the specified address within the provided block range; if using lightwalletd for access to chain data, this may be performed using the GetTaddressTxids RPC method. It should then call wallet::decrypt_and_store_transaction for each transaction so detected. If no transactions are detected within the given range, the caller should instead invoke WalletWrite::notify_address_checked with block_end_height - 1 as the as_of_height argument.

GetSpendingTx(OutPoint)

Available on crate feature spend-index only.

The main-chain transaction that spends of a specific transparent output, or confirmation that the output remains unspent, is requested.

When the spend-index feature is enabled, GetSpendingTx requests will be emitted by the backend instead of TransactionDataRequest::TransactionsInvolvingAddress, in circumstances when spentness determination is needed. This feature should only be enabled for wallets whose chain-data source can resolve the spend of an individual outpoint directly — for example a full node that maintains a spent-outpoint index. It avoids needing to retrieve potentially large amounts of transaction history (in the cas of a heavily-reused address) just to discover whether one output was spent.

The caller evaluating this request on behalf of the wallet backend should determine whether outpoint has been spent on the main chain. Spentness should be taken from an authoritative source (e.g. the node’s UTXO set); the spend index is used only to identify the spending transaction. If the output is spent, the caller should provide the spending transaction to wallet::decrypt_and_store_transaction. If the output is confirmed unspent as of some height, the caller should invoke WalletWrite::notify_output_verified_unspent with that height. If the output is known to be spent but the spending transaction cannot yet be resolved (e.g. an index is still being built — see ZcashFoundation/zebra#10806), the caller should do nothing, so that the request is re-issued and retried later.

Implementations

impl TransactionDataRequest

pub fn transactions_involving_address( address: TransparentAddress, block_range_start: BlockHeight, block_range_end: Option<BlockHeight>, request_at: Option<SystemTime>, tx_status_filter: TransactionStatusFilter, output_status_filter: OutputStatusFilter, ) -> Self

Available on crate feature transparent-inputs only.

Constructs a request for Information about transactions that receive or spend funds belonging to the specified transparent address.

Parameters:

• address: The address to request transactions and/or UTXOs for.
• block_range_start: Only transactions mined at heights greater than or equal to this height should be returned.
• block_range_end: Only transactions mined at heights less than this height should be returned.
• request_at: If a request_at time is set, the caller evaluating this request should attempt to retrieve transaction data related to the specified address at a time that is as close as practical to the specified instant, and in a fashion that decorrelates this request to a light wallet server from other requests made by the same caller. This may be ignored by callers that are able to satisfy the request without exposing correlations between addresses to untrusted parties; for example, a wallet application that uses a private, trusted-for-privacy supplier of chain data can safely ignore this field.
• tx_status_filter: The caller should respond to this request only with transactions that conform to the specified transaction status filter.
• `output_status_filter: The caller should respond to this request only with transactions containing outputs that conform to the specified output status filter.

See TransactionDataRequest::TransactionsInvolvingAddress for more information.

Trait Implementations

impl Clone for TransactionDataRequest

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TransactionDataRequest

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

Formats the value using the given formatter.

impl Eq for TransactionDataRequest

impl Hash for TransactionDataRequest

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for TransactionDataRequest

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for TransactionDataRequest

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for TransactionDataRequest

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for TransactionDataRequest