# Module `iota::address` - [Constants](#@Constants_0) - [Function `to_u256`](#iota_address_to_u256) - [Function `from_u256`](#iota_address_from_u256) - [Function `from_bytes`](#iota_address_from_bytes) - [Function `to_bytes`](#iota_address_to_bytes) - [Function `to_ascii_string`](#iota_address_to_ascii_string) - [Function `to_string`](#iota_address_to_string) - [Function `from_ascii_bytes`](#iota_address_from_ascii_bytes) - [Function `hex_char_value`](#iota_address_hex_char_value) - [Function `length`](#iota_address_length) - [Function `max`](#iota_address_max)

use iota::hex;
use std::ascii;
use std::bcs;
use std::option;
use std::string;
use std::vector;

## Constants The length of an address, in bytes

const LENGTH: u64 = 32;

const MAX: u256 = 115792089237316195423570985008687907853269984665640564039457584007913129639935;

Error from from_bytes when it is supplied too many or too few bytes.

const EAddressParseError: u64 = 0;

## Function `to_u256` Convert a into a u256 by interpreting a as the bytes of a big-endian integer (e.g., to_u256(0x1) == 1)

public fun to_u256(a: address): u256

Implementation

public native fun to_u256(a: address): u256;

## Function `from_u256` Convert n into an address by encoding it as a big-endian integer (e.g., from_u256(1) = @0x1) Aborts if n > MAX_ADDRESS

public fun from_u256(n: u256): address

Implementation

public native fun from_u256(n: u256): address;

## Function `from_bytes` Convert bytes into an address. Aborts with EAddressParseError if the length of bytes is not 32

public fun from_bytes(bytes: vector<u8>): address

Implementation

public native fun from_bytes(bytes: vector<u8>): address;

## Function `to_bytes` Convert a into BCS-encoded bytes.

public fun to_bytes(a: address): vector<u8>

Implementation

public fun to_bytes(a: address): vector<u8> {
    bcs::to_bytes(&a)
}

## Function `to_ascii_string` Convert a to a hex-encoded ASCII string

public fun to_ascii_string(a: address): std::ascii::String

Implementation

public fun to_ascii_string(a: address): ascii::String {
    hex::encode(to_bytes(a)).to_ascii_string()
}

## Function `to_string` Convert a to a hex-encoded string

public fun to_string(a: address): std::string::String

Implementation

public fun to_string(a: address): string::String {
    to_ascii_string(a).to_string()
}

## Function `from_ascii_bytes` Converts an ASCII string to an address, taking the numerical value for each character. The string must be Base16 encoded, and thus exactly 64 characters long. For example, the string "00000000000000000000000000000000000000000000000000000000DEADB33F" will be converted to the address @0xDEADB33F. Aborts with EAddressParseError if the length of s is not 64, or if an invalid character is encountered.

public fun from_ascii_bytes(bytes: &vector<u8>): address

Implementation

public fun from_ascii_bytes(bytes: &vector<u8>): address {
    assert!(bytes.length() == 64, EAddressParseError);
    let mut hex_bytes = vector[];
    let mut i = 0;
    while (i < 64) {
        let hi = hex_char_value(bytes[i]);
        let lo = hex_char_value(bytes[i+1]);
        hex_bytes.push_back((hi << 4) | lo);
        i = i + 2;
    };
    from_bytes(hex_bytes)
}

## Function `hex_char_value`

fun hex_char_value(c: u8): u8

Implementation

fun hex_char_value(c: u8): u8 {
    if (c >= 48 && c <= 57) c - 48 // 0-9
    else if (c >= 65 && c <= 70) c - 55 // A-F
    else if (c >= 97 && c <= 102) c - 87 // a-f
    else abort EAddressParseError
}

## Function `length` Length of an IOTA address in bytes

public fun length(): u64

Implementation

public fun length(): u64 {
    LENGTH
}

## Function `max` Largest possible address

public fun max(): u256

Implementation

public fun max(): u256 {
    MAX
}