Struct Address 

pub struct Address<T: IsAddressKind>(/* private fields */);

An address captures spending and delegation conditions of assets in the network.

Addresses can be one of two kind:

• kind::Byron: legacy, not longer used. Also called “bootstrap” addresses sometimes.
• kind::Shelley: most used and modern format, which can bear delegation rights.

An Address can be constructed in a variety of ways.

1. Either directly using the provided builder:

   • Address<kind::Shelley>::new
   • Address<kind::Shelley>::with_delegation

2. Using the address! or address_test! macros.

3. Or by converting from another representation (e.g. bech32, base58 or base16 text strings, or raw bytes):

   // Parse a string as Shelley address; will fail if presented with a Byron address:
   assert!(
     <Address<kind::Shelley>>::try_from(
       "addr1v83gkkw3nqzakg5xynlurqcfqhgd65vkfvf5xv8tx25ufds2yvy2h"
     ).is_ok()
   );
   
   assert!(
     <Address<kind::Shelley>>::try_from(
       "Ae2tdPwUPEYwNguM7TB3dMnZMfZxn1pjGHyGdjaF4mFqZF9L3bj6cdhiH8t"
     ).is_err()
   );

   // Parse a string as any address; will also success on Byron addresses:
   assert!(
     <Address<kind::Any>>::try_from(
       "addr1v83gkkw3nqzakg5xynlurqcfqhgd65vkfvf5xv8tx25ufds2yvy2h"
     ).is_ok()
   );
   
   assert!(
     <Address<kind::Any>>::try_from(
       "Ae2tdPwUPEYwNguM7TB3dMnZMfZxn1pjGHyGdjaF4mFqZF9L3bj6cdhiH8t"
     ).is_ok()
   );

   // Also work with base16 encoded addresses:
   assert!(
     <Address<kind::Shelley>>::try_from(
       "61e28b59d19805db228624ffc1830905d0dd51964b134330eb32a9c4b6"
     ).is_ok()
   );

Implementations

impl Address<Shelley>

pub fn new(network: NetworkId, payment: Credential) -> Self

See also address!/address_test!

pub fn with_delegation(self, delegation: Credential) -> Self

See also address!/address_test!

impl Address<Shelley>

pub fn network_id(&self) -> NetworkId

pub fn payment(&self) -> Credential

pub fn delegation(&self) -> Option<Credential>

impl<T: IsAddressKind> Address<T>

pub fn is_byron(&self) -> bool

Check whether an address is a kind::Byron address. To carry this proof at the type-level, use Self::as_byron.

examples

assert_eq!(
    address!(
        "37btjrVyb4KDXBNC4haBVPCrro8AQPHwvCMp3R\
         FhhSVWwfFmZ6wwzSK6JK1hY6wHNmtrpTf1kdbv\
         a8TCneM2YsiXT7mrzT21EacHnPpz5YyUdj64na"
    ).is_byron(),
    true,
);

assert_eq!(
    address!("addr1v83gkkw3nqzakg5xynlurqcfqhgd65vkfvf5xv8tx25ufds2yvy2h").is_byron(),
    false,
);

pub fn as_byron(&self) -> Option<Address<Byron>>

Refine the kind of the address, assuming it is a kind::Byron to enable specific methods for this kind.

pub fn is_shelley(&self) -> bool

Check whether an address is a kind::Byron address. To carry this proof at the type-level, use Self::as_shelley.

examples

assert_eq!(
    address!(
        "37btjrVyb4KDXBNC4haBVPCrro8AQPHwvCMp3R\
         FhhSVWwfFmZ6wwzSK6JK1hY6wHNmtrpTf1kdbv\
         a8TCneM2YsiXT7mrzT21EacHnPpz5YyUdj64na"
    ).is_shelley(),
    false,
);

assert_eq!(
    address!("addr1v83gkkw3nqzakg5xynlurqcfqhgd65vkfvf5xv8tx25ufds2yvy2h").is_shelley(),
    true,
);

pub fn as_shelley(&self) -> Option<Address<Shelley>>

Refine the kind of the address, assuming it is a kind::Shelley to enable specific methods for this kind.

Trait Implementations

impl<T: Clone + IsAddressKind> Clone for Address<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + IsAddressKind> Debug for Address<T>

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

Formats the value using the given formatter.

impl Default for Address<Any>

fn default() -> Self

Returns the “default value” for a type.

impl<T: IsAddressKind> Display for Address<T>

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

Formats the value using the given formatter.

impl<T: IsAddressKind> From<&Address<T>> for Vec<u8>

fn from(address: &Address<T>) -> Self

Converts to this type from the input type.

impl From<Address<Byron>> for Address<Any>

fn from(byron_address: Address<Byron>) -> Self

Converts to this type from the input type.

impl From<Address<Shelley>> for Address<Any>

fn from(shelley_address: Address<Shelley>) -> Self

Converts to this type from the input type.

impl From<ByronAddress> for Address<Byron>

fn from(byron_address: ByronAddress) -> Self

Converts to this type from the input type.

impl From<ShelleyAddress> for Address<Shelley>

fn from(shelley_address: ShelleyAddress) -> Self

Converts to this type from the input type.

impl<T: IsAddressKind> FromStr for Address<T>

where Address<T>: for<'a> TryFrom<&'a str, Error = Error>,

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Address<T>>

Parses a string s to return a value of this type.

impl<T: IsAddressKind + Eq> Ord for Address<T>

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

impl<T: PartialEq + IsAddressKind> PartialEq for Address<T>

fn eq(&self, other: &Address<T>) -> 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<T: IsAddressKind + Eq> PartialOrd for Address<T>

fn partial_cmp(&self, rhs: &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<T: IsAddressKind> TryFrom<&[u8]> for Address<T>

where Address<T>: TryFrom<Address, Error = Error>,

type Error = Error

The type returned in the event of a conversion error.

fn try_from(bytes: &[u8]) -> Result<Self>

Performs the conversion.

impl<T: IsAddressKind> TryFrom<&str> for Address<T>

where Address<T>: TryFrom<Address, Error = Error>,

type Error = Error

The type returned in the event of a conversion error.

fn try_from(text: &str) -> Result<Self>

Performs the conversion.

impl TryFrom<Address> for Address<Any>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(address: Address) -> Result<Self>

Performs the conversion.

impl TryFrom<Address> for Address<Shelley>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(address: Address) -> Result<Self>

Performs the conversion.

impl<T: Eq + IsAddressKind> Eq for Address<T>

impl<T: IsAddressKind> StructuralPartialEq for Address<T>