Struct Address

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

A struct representing a blockchain address. This struct provides various utility methods for working with addresses, including conversions from and to Bech32 string representations and byte arrays.

Serialization

This struct is serializable with the serde crate.

Cloning

Cloning is supported.

Debugging

Debug printouts are supported.

Examples

Basic usage:

let address = Address::from_bech32_string("erd1qqqqqqqqqqqqqpgq7ykazrzd905zvnlr88dpfw06677lxe9w0n4suz00uh").unwrap();
let bech32 = address.to_bech32_string().unwrap();
assert_eq!(bech32, "erd1qqqqqqqqqqqqqpgq7ykazrzd905zvnlr88dpfw06677lxe9w0n4suz00uh");

Implementations

impl Address

The Address struct provides an abstraction over a blockchain address, with various utility methods for working with addresses.

pub fn from_bech32_string(bech32: &str) -> Result<Address, DataError>

Creates an Address instance from a Bech32 string representation.

Parameters

• bech32: The Bech32 string representation of the address.

Returns

• An Ok(Address) instance if the conversion is successful.
• An Err(DataError) if the Bech32 string is invalid.

Example

let address = Address::from_bech32_string("erd1qqqqqqqqqqqqqpgq7ykazrzd905zvnlr88dpfw06677lxe9w0n4suz00uh").unwrap();

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

Creates an Address instance from a byte array.

Parameters

• bytes: A byte array of length 32.

Returns

• An Address instance.

Example

let address = Address::from_bytes([0_u8; 32]);

pub fn to_bech32_string(&self) -> Result<String, DataError>

Converts the Address instance to a Bech32 string representation.

Returns

• An Ok(String) containing the Bech32 string representation if successful.
• An Err(DataError) if the conversion fails.

Example

let bech32_string = address.to_bech32_string().unwrap();

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

Converts the Address instance to a byte array.

Returns

• A byte array of length 32.

Example

let bytes = address.to_bytes();
assert_eq!(bytes, [0_u8; 32]);

Methods from Deref<Target = Address>

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

pub fn to_bech32_string(&self) -> Result<String, Error>

pub fn is_valid(&self) -> bool

Trait Implementations

impl Clone for Address

fn clone(&self) -> Address

Returns a copy 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

Formats the value using the given formatter.

impl Default for Address

fn default() -> Self

Returns the “default value” for a type.

impl Deref for Address

type Target = Address

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a> Deserialize<'a> for Address

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

where D: Deserializer<'a>,

Deserialize this value from the given Serde deserializer.

impl From<&Address> for Address

fn from(value: &SDKAddress) -> Self

Converts to this type from the input type.

impl From<&Address> for Address

fn from(value: &Address) -> Self

Converts to this type from the input type.

impl From<&Address> for AddressValue

fn from(value: &Address) -> Self

Converts to this type from the input type.

impl From<&String> for Address

fn from(value: &String) -> Self

Converts to this type from the input type.

impl From<&str> for Address

fn from(value: &str) -> Self

Converts to this type from the input type.

impl From<Address> for Address

fn from(value: SDKAddress) -> Self

Converts to this type from the input type.

impl From<Address> for Address

fn from(value: Address) -> Self

Converts to this type from the input type.

impl From<Address> for Address

fn from(value: Address) -> Self

Converts to this type from the input type.

impl Hash for Address

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 ManagedConvertible<ManagedAddress<VMHooksApi<StaticApiBackend>>> for Address

fn to_managed(&self) -> ManagedAddress<StaticApi>

Converts the native Rust type to the specified managed type.

impl NativeConvertible for Address

type Native = Address

The native Rust type to which the managed type will be converted.

fn to_native(&self) -> Self::Native

Converts the managed type to the specified native Rust type.

impl PartialEq for Address

fn eq(&self, other: &Self) -> 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 Serialize for Address

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TopDecode for Address

fn top_decode<I>(input: I) -> Result<Self, DecodeError>

where I: TopDecodeInput,

Attempt to deserialize the value from input.

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<Self, <H as DecodeErrorHandler>::HandledErr>

where I: TopDecodeInput, H: DecodeErrorHandler,

Version of top_decode that can handle errors as soon as they occur. For instance it can exit immediately and make sure that if it returns, it is a success. By not deferring error handling, this can lead to somewhat smaller bytecode.