Struct AddressTransaction 

pub struct AddressTransaction {
    address_location: OutputLocation,
    transaction_location: TransactionLocation,
}

A single transaction sent to a transparent::Address.

We store both the address location key and transaction location value in the RocksDB column family key. This improves insert and delete performance.

This requires 8 extra bytes for each transaction location, because we repeat the key for each value. But RocksDB compression reduces the duplicate data size on disk.

Fields

address_location: OutputLocation

The location of the first transparent::Output sent to the address in output.

transaction_location: TransactionLocation

The location of the transaction sent to the address.

Implementations

impl AddressTransaction

pub fn new( address_location: OutputLocation, transaction_location: TransactionLocation, ) -> AddressTransaction

Create a new AddressTransaction from an address location, and a transaction location.

pub fn address_iterator_range( address_location: OutputLocation, query: RangeInclusive<Height>, ) -> RangeInclusive<AddressTransaction>

Create a range of AddressTransactions which starts iteration for the supplied address. Starts at the first UTXO, or at the query start height, whichever is greater. Ends at the maximum possible transaction index for the end height.

Used to look up transactions with DiskDb::zs_forward_range_iter.

The transaction locations in the:

• start bound might be invalid, if it is based on the query start height.
• end bound will always be invalid.

But this is not an issue, since DiskDb::zs_forward_range_iter will fetch all existing (valid) values in the range.

pub fn address_iterator_next(&mut self)

Update the transaction location to the next possible transaction for the supplied address. Used to look up the next output with ReadDisk::zs_next_key_value_from.

The updated transaction location may be invalid, which is not an issue since ReadDisk::zs_next_key_value_from will fetch the next existing (valid) value.

pub fn address_location(&self) -> OutputLocation

The location of the first transparent::Output sent to the address of this output.

This can be used to look up the address.

pub fn transaction_location(&self) -> TransactionLocation

The location of this transaction.

pub fn address_location_mut(&mut self) -> &mut OutputLocation

Allows tests to modify the address location.

pub fn transaction_location_mut(&mut self) -> &mut TransactionLocation

Allows tests to modify the unspent output location.

Trait Implementations

impl Arbitrary for AddressTransaction

type Parameters = (<OutputLocation as Arbitrary>::Parameters, <TransactionLocation as Arbitrary>::Parameters)

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = Map<(<OutputLocation as Arbitrary>::Strategy, <TransactionLocation as Arbitrary>::Strategy), fn((OutputLocation, TransactionLocation)) -> AddressTransaction>

The type of Strategy used to generate values of type Self.

fn arbitrary_with(_top: Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl Clone for AddressTransaction

fn clone(&self) -> AddressTransaction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AddressTransaction

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AddressTransaction

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FromDisk for AddressTransaction

fn from_bytes(disk_bytes: impl AsRef<[u8]>) -> Self

Converts raw disk bytes back into the deserialized type.

impl IntoDisk for AddressTransaction

type Bytes = [u8; 13]

The type used to write bytes to disk, and compare a value as a key to on-disk keys.

fn as_bytes(&self) -> Self::Bytes

Converts the current type into serialized raw bytes.

impl Ord for AddressTransaction

fn cmp(&self, other: &AddressTransaction) -> 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.

impl PartialEq for AddressTransaction

fn eq(&self, other: &AddressTransaction) -> 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 PartialOrd for AddressTransaction

fn partial_cmp(&self, other: &AddressTransaction) -> 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 Serialize for AddressTransaction

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for AddressTransaction

impl Eq for AddressTransaction

impl StructuralPartialEq for AddressTransaction

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 20 bytes