Struct IotaAddress 

pub struct IotaAddress(/* private fields */);

Unique identifier for an Account on the IOTA blockchain.

An Address is a 32-byte pseudonymous identifier used to uniquely identify an account and asset-ownership on the IOTA blockchain. Often, human-readable addresses are encoded in hexadecimal with a 0x prefix. For example, this is a valid IOTA address: 0x02a212de6a9dfa3a69e22387acfbafbb1a9e591bd9d636e7895dcfc8de05f331.

use iota_sdk_types::Address;

let hex = "0x02a212de6a9dfa3a69e22387acfbafbb1a9e591bd9d636e7895dcfc8de05f331";
let address = Address::from_hex(hex).unwrap();
println!("Address: {}", address);
assert_eq!(hex, address.to_string());

Deriving an Address

Addresses are cryptographically derived from a number of user account authenticators, the simplest of which is an Ed25519PublicKey.

Deriving an address consists of the Blake2b256 hash of the sequence of bytes of its corresponding authenticator, prefixed with a domain-separator (except ed25519, for compatibility reasons). For each other authenticator, this domain-separator is the single byte-value of its SignatureScheme flag. E.g. hash(signature schema flag || authenticator bytes).

Each authenticator has a method for deriving its Address as well as documentation for the specifics of how the derivation is done. See Ed25519PublicKey::derive_address for an example.

Relationship to ObjectIds

ObjectIds and Addresses share the same 32-byte addressable space but are derived leveraging different domain-separator values to ensure that, cryptographically, there won’t be any overlap, e.g. there can’t be a valid Object who’s ObjectId is equal to that of the Address of a user account.

BCS

An Address’s BCS serialized form is defined by the following:

address = 32OCTET

Implementations

impl Address

pub const LENGTH: usize = 32

pub const ZERO: Address

pub const MAX: Address

pub const STD: Address

pub const FRAMEWORK: Address

pub const SYSTEM: Address

pub const GENESIS_BRIDGE: Address

pub const STARDUST: Address

pub const SYSTEM_STATE: Address

pub const CLOCK: Address

pub const AUTHENTICATOR_STATE: Address

pub const RANDOMNESS_STATE: Address

pub const GENESIS_IOTA_BRIDGE: Address

pub const DENY_LIST: Address

pub const fn new(bytes: [u8; 32]) -> Address

pub const fn from_u16(suffix: u16) -> Address

Creates an Address from a u16 suffix by setting the last two bytes.

pub fn is_system_package(&self) -> bool

Checks if the address is one of the system package addresses. The system packages are:

• STD
• FRAMEWORK
• SYSTEM
• GENESIS_BRIDGE
• STARDUST

pub fn generate<R>(rng: R) -> Address

where R: RngCore + CryptoRng,

pub fn random() -> Address

pub const fn into_bytes(self) -> [u8; 32]

Return the underlying byte array of a Address.

pub const fn bytes(&self) -> &[u8; 32]

pub const fn as_bytes(&self) -> &[u8]

pub const fn from_object_id(object_id: ObjectId) -> Address

pub fn from_hex<T>(hex: T) -> Result<Address, AddressParseError>

where T: AsRef<[u8]>,

Parses an Address from a full-length hex string (64 hex characters), with or without a 0x prefix. Will return an error if the string is not exactly 64 hex characters long (excluding the 0x prefix).

pub fn from_prefixed_hex<T>(hex: T) -> Result<Address, AddressParseError>

where T: AsRef<[u8]>,

Parses an Address from a full-length hex string (64 hex characters), with a mandatory 0x prefix. Will return an error if the string is not exactly 64 hex characters long (excluding the 0x prefix).

pub fn from_short_hex<T>(hex: T) -> Result<Address, AddressParseError>

where T: AsRef<[u8]>,

Parses an Address from a hex string, with or without a 0x prefix. The string can be of variable length; if it’s shorter than 64 hex characters, it will be left-padded with 0s.

pub fn from_prefixed_short_hex<T>(hex: T) -> Result<Address, AddressParseError>

where T: AsRef<[u8]>,

Parses an Address from a hex string with a mandatory 0x prefix. The string can be of variable length; if it’s shorter than 64 hex characters, it will be left-padded with 0s.

pub fn to_hex(&self) -> String

Returns the string representation of this address in hex format with 0x prefix.

pub fn to_raw_hex(&self) -> String

Returns the string representation of this address in hex format without 0x prefix.

pub fn to_short_hex(&self) -> String

Returns the shortest possible string representation of the address (i.e. with leading zeroes trimmed).

pub fn to_raw_short_hex(&self) -> String

Returns the shortest possible string representation of the address (i.e. with leading zeroes trimmed), without 0x prefix.

pub fn to_canonical_string(&self, with_prefix: bool) -> String

Returns the string representation of this address using the canonical display, with or without a 0x prefix.

pub fn from_bytes<T>(bytes: T) -> Result<Address, AddressParseError>

where T: AsRef<[u8]>,

pub const fn next_lexicographical(&self) -> Address

Returns the next address in byte-increasing order.

pub const fn next_lexicographical_opt(&self) -> Option<Address>

Returns the next address in byte-increasing order, or None if the result would overflow.

Trait Implementations

impl Arbitrary for Address

type Parameters = ()

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

type Strategy = BoxedStrategy<Address>

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

fn arbitrary_with( args_shared: <Address as Arbitrary>::Parameters, ) -> <Address as Arbitrary>::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 AsRef<[u8]> for Address

fn as_ref(&self) -> &[u8]

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<[u8; 32]> for Address

fn as_ref(&self) -> &[u8; 32]

Converts this type into a shared reference of the (usually inferred) input type.

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<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Address

fn deserialize<__D>( __deserializer: __D, ) -> Result<Address, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Address

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

Formats the value using the given formatter.

impl From<&MultiSigPublicKey> for IotaAddress

fn from(multisig_pk: &MultiSigPublicKey) -> Self

Derive a IotaAddress from [struct MultiSigPublicKey]. A MultiSig address is defined as the 32-byte Blake2b hash of serializing the flag, the threshold, concatenation of all n flag, public keys and its weight. flag_MultiSig || threshold || flag_1 || pk_1 || weight_1 || ... || flag_n || pk_n || weight_n.

impl From<&PublicKey> for IotaAddress

fn from(pk: &PublicKey) -> Self

Converts to this type from the input type.

impl From<[u8; 32]> for Address

fn from(address: [u8; 32]) -> Address

Converts to this type from the input type.

impl From<Address> for [u8; 32]

fn from(address: Address) -> [u8; 32]

Converts to this type from the input type.

impl From<Address> for ObjectId

fn from(value: Address) -> ObjectId

Converts to this type from the input type.

impl From<Address> for Vec<u8>

fn from(value: Address) -> Vec<u8>

Converts to this type from the input type.

impl From<ObjectId> for Address

fn from(value: ObjectId) -> Address

Converts to this type from the input type.

impl FromStr for Address

type Err = AddressParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Address, <Address as FromStr>::Err>

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

impl Hash for Address

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

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 MoveTypeTagTrait for IotaAddress

fn get_type_tag() -> TypeTag

impl Ord for Address

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

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

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&GenericSignature> for IotaAddress

fn try_from(sig: &GenericSignature) -> IotaResult<Self>

Derive a IotaAddress from a serialized signature in IOTA GenericSignature.

type Error = IotaError

The type returned in the event of a conversion error.

impl Copy for Address

impl Eq for Address

impl StructuralPartialEq for Address