Struct Address 

pub struct Address<const ADDRESS_BYTES: u128> {
    pub(crate) network: Network,
    pub(crate) kind: AddressType,
    pub(crate) spend: Point,
    pub(crate) view: Point,
}

A Monero address.

Fields

network: Network

kind: AddressType

spend: Point

view: Point

Implementations

impl<const ADDRESS_BYTES: u128> Address<ADDRESS_BYTES>

pub(crate) const BASE_256_UPPER_BOUND: UpperBound<usize>

The upper bound on an address’s data, when represented as bytes without a checksum.

pub(crate) const CHECKSUMMED_UPPER_BOUND: UpperBound<usize>

The upper bound on an address’s data, when represented as bytes with a checksum.

pub const SIZE_UPPER_BOUND: UpperBound<usize>

The maximum size of an encoded address.

pub fn new( network: Network, kind: AddressType, spend: Point, view: Point, ) -> Self

Create a new address.

pub fn from_str_with_unchecked_network(s: &str) -> Result<Self, AddressError>

Parse an address from a String, accepting any network it is.

pub fn from_str(network: Network, s: &str) -> Result<Self, AddressError>

Create a new address from a &str.

This takes in an argument for the expected network, erroring if a distinct network was used. It also errors if the address is invalid (as expected).

pub fn with_payment_id(&self, payment_id: [u8; 8]) -> Result<Self, AddressError>

Produce this address with the specified payment_id embedded.

This will convert a standard address to an integrated address. For integrated/guaranteed addresses, this will replace any existing payment_id.

If the address type cannot have a payment_id embedded (e.g. AddressType::Subaddress), an error will be returned..

pub fn network(&self) -> Network

The network this address is intended for use on.

pub fn kind(&self) -> &AddressType

The type of address this is.

pub fn is_subaddress(&self) -> bool

If this is a subaddress.

pub fn payment_id(&self) -> Option<[u8; 8]>

The payment ID for this address.

pub fn is_guaranteed(&self) -> bool

If this address is guaranteed.

A guaranteed address is one where any outputs scanned to it are guaranteed to be spendable under the hardness of various cryptographic problems (which are assumed hard). This is via a modified shared-key derivation which eliminates the burning bug.

pub fn spend(&self) -> Point

The public spend key for this address.

pub fn view(&self) -> Point

The public view key for this address.

Trait Implementations

impl<const ADDRESS_BYTES: u128> Clone for Address<ADDRESS_BYTES>

fn clone(&self) -> Address<ADDRESS_BYTES>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const ADDRESS_BYTES: u128> Debug for Address<ADDRESS_BYTES>

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

Formats the value using the given formatter.

impl<const ADDRESS_BYTES: u128> Display for Address<ADDRESS_BYTES>

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

Formats the value using the given formatter.

impl<const ADDRESS_BYTES: u128> Eq for Address<ADDRESS_BYTES>

#[doc(hidden)] fn assert_receiver_is_total_eq(&self)

impl<const ADDRESS_BYTES: u128> PartialEq for Address<ADDRESS_BYTES>

fn eq(&self, other: &Address<ADDRESS_BYTES>) -> 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<const ADDRESS_BYTES: u128> Zeroize for Address<ADDRESS_BYTES>

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.

impl<const ADDRESS_BYTES: u128> Copy for Address<ADDRESS_BYTES>

impl<const ADDRESS_BYTES: u128> StructuralPartialEq for Address<ADDRESS_BYTES>

impl<const ADDRESS_BYTES: u128> TrivialClone for Address<ADDRESS_BYTES>