Struct AccountAddress 

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

A 32-byte Aptos account address.

Account addresses on Aptos are derived from public keys through a specific derivation scheme that includes an authentication key prefix.

Display Format (AIP-40)

The Display trait follows AIP-40:

• Special addresses (0x1 through 0xf) use SHORT format: 0x1, 0x3, 0xa
• Normal addresses use LONG format: full 64 hex characters with 0x prefix

Use to_long_string() to always get the full 64-character format, or to_short_string() to always get the trimmed format.

Example

use aptos_sdk::AccountAddress;

// Parse from hex string
let addr = AccountAddress::from_hex("0x1").unwrap();

// Display uses AIP-40: SHORT for special addresses
assert_eq!(addr.to_string(), "0x1");

// Explicit long/short string methods
assert_eq!(addr.to_long_string(), "0x0000000000000000000000000000000000000000000000000000000000000001");
assert_eq!(addr.to_short_string(), "0x1");

Implementations

impl AccountAddress

pub const ZERO: Self

The “zero” address (all zeros).

pub const ONE: Self

The core framework address (0x1).

pub const THREE: Self

The token framework address (0x3).

pub const FOUR: Self

The fungible asset framework address (0x4).

pub const A: Self

The APT fungible asset metadata address (0xa).

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

Creates an address from a byte array.

pub fn from_hex<T: AsRef<[u8]>>(hex_str: T) -> AptosResult<Self>

Creates an address from a hex string (with or without 0x prefix).

The hex string must contain at least one hex digit. Empty strings and bare “0x” prefixes are rejected as invalid addresses.

Errors

Returns an error if the input is empty, contains invalid UTF-8, has no hex digits after the prefix, exceeds the maximum length (64 hex characters), or contains invalid hex characters.

pub fn from_bytes<T: AsRef<[u8]>>(bytes: T) -> AptosResult<Self>

Creates an address from a byte slice.

Errors

Returns an error if the byte slice is not exactly 32 bytes long.

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

Returns the address as a byte slice.

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

Returns the address as a byte array.

pub fn to_hex(&self) -> String

Returns the address as a hex string with 0x prefix (always 66 characters).

This is an alias for to_long_string().

pub fn to_long_string(&self) -> String

Returns the full 64-character hex string with 0x prefix.

This always returns the LONG format regardless of whether the address is special. For example, 0x1 becomes 0x0000000000000000000000000000000000000000000000000000000000000001.

pub fn to_short_string(&self) -> String

Returns a short hex string, trimming leading zeros.

For example, 0x0000...0001 becomes 0x1.

pub fn to_standard_string(&self) -> String

Returns the standard string representation following AIP-40.

• Special addresses (0x1 through 0xf) use SHORT format
• Normal addresses use LONG format (full 64 hex characters)

pub fn is_zero(&self) -> bool

Returns true if this is the zero address.

pub fn is_special(&self) -> bool

Returns true if this is a “special” address (first 63 bytes are zero, and the last byte is non-zero and less than 16).

Special addresses include framework addresses like 0x1, 0x3, 0x4.

Trait Implementations

impl AsRef<[u8]> for AccountAddress

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

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

impl Clone for AccountAddress

fn clone(&self) -> AccountAddress

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AccountAddress

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

Formats the value using the given formatter.

impl Default for AccountAddress

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for AccountAddress

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for AccountAddress

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

Formats the address following AIP-40:

• Special addresses (0x1 through 0xf) use SHORT format
• Normal addresses use LONG format (full 64 hex characters)

impl From<[u8; 32]> for AccountAddress

fn from(bytes: [u8; 32]) -> Self

Converts to this type from the input type.

impl From<AccountAddress> for [u8; 32]

fn from(addr: AccountAddress) -> Self

Converts to this type from the input type.

impl From<AuthenticationKey> for AccountAddress

fn from(key: AuthenticationKey) -> Self

Converts to this type from the input type.

impl FromStr for AccountAddress

type Err = AptosError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

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

impl Hash for AccountAddress

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 Ord for AccountAddress

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

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

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

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for AccountAddress

impl Eq for AccountAddress

impl StructuralPartialEq for AccountAddress