Struct Address 

pub struct Address { /* private fields */ }

A user-facing address in Miden.

An address consists of an AddressId and optional RoutingParameters.

A user who wants to receive a note creates an address and sends it to the sender of the note. The sender creates a note intended for the holder of this address ID (e.g., it provides discoverability and potentially access-control) and the routing parameters inform the sender about various aspects like:

• what kind of note the receiver’s account can consume.
• how the receiver discovers the note.
• how to encrypt the note for the receiver.

It can be encoded to a string using Self::encode and decoded using Self::decode. If routing parameters are present, the ID and parameters are separated by Address::SEPARATOR.

Example

# account ID
mm1apt3l475qemeqqp57xjycfdwcvw0sfhq
# account ID + routing parameters (interface & note tag length)
mm1apt3l475qemeqqp57xjycfdwcvw0sfhq_qruqqypuyph
# account ID + routing parameters (interface, note tag length, encryption key)
mm1apt3l475qemeqqp57xjycfdwcvw0sfhq_qruqqqgqjmsgjsh3687mt2w0qtqunxt3th442j48qwdnezl0fv6qm3x9c8zqsv7pku

The encoding of an address without routing parameters matches the encoding of the underlying identifier exactly (e.g. an account ID). This provides compatibility between identifiers and addresses and gives end-users a hint that an address is only an extension of the identifier (e.g. their account’s ID) that they are likely to recognize.

Implementations

impl Address

pub const SEPARATOR: char = '_'

The separator character in an encoded address between the ID and routing parameters.

pub fn new(id: impl Into<AddressId>) -> Self

Returns a new address from an AddressId and routing parameters set to None.

To set routing parameters, use Self::with_routing_parameters.

pub fn with_routing_parameters( self, routing_params: RoutingParameters, ) -> Result<Self, AddressError>

For local (both public and private) accounts, up to 30 bits can be encoded into the tag. For network accounts, the tag length must be set to 30 bits.

Errors

Returns an error if:

• The tag length routing parameter is not NoteTag::DEFAULT_NETWORK_TAG_LENGTH for network accounts.

pub fn id(&self) -> AddressId

Returns the identifier of the address.

pub fn interface(&self) -> Option<AddressInterface>

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

pub fn note_tag_len(&self) -> u8

Returns the preferred tag length.

This is guaranteed to be in range 0..=30 (e.g. the maximum of NoteTag::MAX_LOCAL_TAG_LENGTH and NoteTag::DEFAULT_NETWORK_TAG_LENGTH).

pub fn to_note_tag(&self) -> NoteTag

Returns a note tag derived from this address.

pub fn encryption_key(&self) -> Option<&SealingKey>

Returns the optional public encryption key from routing parameters.

This key can be used for sealed box encryption when sending notes to this address.

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

Encodes the Address into a string.

Encoding

The encoding of an address into a string is done as follows:

• Encode the underlying AddressId to a bech32 string.
• If routing parameters are present:
  • Append the Address::SEPARATOR to that string.
  • Append the encoded routing parameters to that string.

pub fn decode(address_str: &str) -> Result<(NetworkId, Self), AddressError>

Decodes an address string into the NetworkId and an Address.

See Address::encode for details on the format. The procedure for decoding the string 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 Deserializable for Address

fn read_from<R: ByteReader>( source: &mut R, ) -> Result<Self, DeserializationError>

Reads a sequence of bytes from the provided source, attempts to deserialize these bytes into Self, and returns the result.

fn read_from_bytes(bytes: &[u8]) -> Result<Self, DeserializationError>

Attempts to deserialize the provided bytes into Self and returns the result.

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

fn write_into<W: ByteWriter>(&self, target: &mut W)

Serializes self into bytes and writes these bytes into the target.

fn to_bytes(&self) -> Vec<u8>

Serializes self into a vector of bytes.

fn get_size_hint(&self) -> usize

Returns an estimate of how many bytes are needed to represent self.

impl Eq for Address

impl StructuralPartialEq for Address