Skip to main content

Module sui::address

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

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
Click to open
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
Click to open
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
Click to open
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>
Click to open
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
Click to open
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
Click to open
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
Click to open
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
Click to open
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 a Sui address in bytes

public fun length(): u64
Click to open
Implementation
public fun length(): u64 {
    LENGTH
}

Function max​

Largest possible address

public fun max(): u256
Click to open
Implementation
public fun max(): u256 {
    MAX
}