Skip to main content

Address

Address​

class Address

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.

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

debugDescription​

var debugDescription: String { get }

A textual representation of this instance, suitable for debugging.

Calling this property directly is discouraged. Instead, convert an instance of any type to a string by using the String(reflecting:) initializer. This initializer works with any type, and uses the custom debugDescription property for types that conform to CustomDebugStringConvertible:

struct Point: CustomDebugStringConvertible {
    let x: Int, y: Int

    var debugDescription: String {
        return "(\(x), \(y))"
    }
}

let p = Point(x: 21, y: 30)
let s = String(reflecting: p)
print(s)
// Prints "(21, 30)"

The conversion of p to a string in the assignment to s uses the Point type's debugDescription property.

description​

var description: String { get }

A textual representation of this instance.

Calling this property directly is discouraged. Instead, convert an instance of any type to a string by using the String(describing:) initializer. This initializer works with any type, and uses the custom description property for types that conform to CustomStringConvertible:

struct Point: CustomStringConvertible {
    let x: Int, y: Int

    var description: String {
        return "(\(x), \(y))"
    }
}

let p = Point(x: 21, y: 30)
let s = String(describing: p)
print(s)
// Prints "(21, 30)"

The conversion of p to a string in the assignment to s uses the Point type's description property.

hash(into:)​

func hash(into hasher: inout Hasher)

Hashes the essential components of this value by feeding them into the given hasher.

Implement this method to conform to the Hashable protocol. The components used for hashing must be the same as the components compared in your type's == operator implementation. Call hasher.combine(_:) with each of these components.

  • Important: In your implementation of hash(into:), don't call finalize() on the hasher instance provided, or replace it with a different instance. Doing so may become a compile-time error in the future.

  • Parameter hasher: The hasher to use when combining the components of this instance.

nextLexicographical()​

func nextLexicographical() -> Address

Returns the next digest in byte-increasing order.

nextLexicographicalOpt()​

func nextLexicographicalOpt() -> Address?

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

toBytes()​

func toBytes() -> Data

toCanonicalString(withPrefix:)​

func toCanonicalString(withPrefix: Bool) -> String

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

toHex()​

func toHex() -> String

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

toRawHex()​

func toRawHex() -> String

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

toRawShortHex()​

func toRawShortHex() -> String

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

toShortHex()​

func toShortHex() -> String

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

authenticatorState()​

static func authenticatorState() -> Address

clock()​

static func clock() -> Address

denyList()​

static func denyList() -> Address

framework()​

static func framework() -> Address

fromBytes(bytes:)​

static func fromBytes(bytes: Data) throws -> Address

fromHex(hex:)​

static func fromHex(hex: String) throws -> Address

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).

fromPrefixedHex(hex:)​

static func fromPrefixedHex(hex: String) throws -> Address

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).

fromPrefixedShortHex(hex:)​

static func fromPrefixedShortHex(hex: String) throws -> Address

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.

fromShortHex(hex:)​

static func fromShortHex(hex: String) throws -> Address

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.

genesisBridge()​

static func genesisBridge() -> Address

genesisIotaBridge()​

static func genesisIotaBridge() -> Address

max()​

static func max() -> Address

random()​

static func random() -> Address

randomnessState()​

static func randomnessState() -> Address

stardust()​

static func stardust() -> Address

std()​

static func std() -> Address

system()​

static func system() -> Address

systemState()​

static func systemState() -> Address

transactionDenyRules()​

static func transactionDenyRules() -> Address

zero()​

static func zero() -> Address

!=(_:_:)​

static func != (lhs: Self, rhs: Self) -> Bool

Returns a Boolean value indicating whether two values are not equal.

Inequality is the inverse of equality. For any values a and b, a != b implies that a == b is false.

This is the default implementation of the not-equal-to operator (!=) for any type that conforms to Equatable.

  • Parameters:
    • lhs: A value to compare.
    • rhs: Another value to compare.

==(_:_:)​

static func == (self: Address, other: Address) -> Bool

Returns a Boolean value indicating whether two values are equal.

Equality is the inverse of inequality. For any values a and b, a == b implies that a != b is false.

  • Parameters:
    • lhs: A value to compare.
    • rhs: Another value to compare.