Enum Address 

#[non_exhaustive]
pub enum Address {
    AccountId(AccountIdAddress),
}

A user-facing address in Miden.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

AccountId(AccountIdAddress)

Implementations

impl Address

pub fn to_note_tag(&self) -> NoteTag

Returns a note tag derived from this address.

pub fn interface(&self) -> AddressInterface

Returns the AddressInterface of the account to which the address points.

pub fn to_bech32(&self, network_id: NetworkId) -> String

Encodes the Address into a bech32 string.

Encoding

The encoding of an address into bech32 is done as follows:

• Encode the underlying address to bytes.
• Into that data, insert the AddressType byte at index 0, shifting all other elements to the right.
• Choose an HRP, defined as a NetworkId, e.g. NetworkId::Mainnet whose string representation is mm.
• Encode the resulting HRP together with the data into a bech32 string using the bech32::Bech32m checksum algorithm.

This is an example of an address in bech32 representation:

mm1qpkdyek2c0ywwvzupakc7zlzty8qn2qnfc

Rationale

The address type is at the very beginning so that it can be decoded first to detect the type of the address, without having to decode the entire data. Moreover, since the address type is chosen as a multiple of 8, the first character of the bech32 string after the 1 separator will be different for every address type. That makes the type of the address conveniently human-readable.

The only allowed checksum algorithm is Bech32m due to being the best available checksum algorithm with no known weaknesses (unlike Bech32). No checksum is also not allowed since the intended use of bech32 is to have error detection capabilities.

pub fn from_bech32( bech32_string: &str, ) -> Result<(NetworkId, Self), AddressError>

Decodes a bech32 string into the NetworkId and an Address.

See Address::to_bech32 for details on the format. The procedure for decoding the bech32 data into the address are the inverse operations of encoding.

Trait Implementations

impl Clone for Address

fn clone(&self) -> Address

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Address

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

Formats the value using the given formatter.

impl From<AccountIdAddress> for Address

fn from(addr: AccountIdAddress) -> Self

Converts to this type from the input type.

impl Hash for Address

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 PartialEq for Address

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

impl StructuralPartialEq for Address