Struct clarity::address::Address

pub struct Address { /* fields omitted */ }

Representation of an Ethereum address.

Address is usually derived from a PrivateKey, or converted from its textual representation.

Methods

impl Address

pub fn new() -> Address

Creates new Address filled with zeros.

The actual implementation of this doesn't really creates the zeros. In our case we treat it as "empty" address, which is then reperesented by zeros.

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

Get raw bytes of the address.

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 From<Address> for Token

fn from(v: Address) -> Token

Performs the conversion.

impl From<[u8; 20]> for Address

fn from(val: [u8; 20]) -> Address

Performs the conversion.

impl<'a> From<&'a [u8]> for Address

fn from(val: &'a [u8]) -> Address

Performs the conversion.

impl Eq for Address

impl ToString for Address

fn to_string(&self) -> String

Creates a textual representation of the Address.

Examples

use clarity::Address;
let address = Address::default();
address.to_string(); // 0x0000000000000000000000000000000000000000

impl PartialOrd<Address> for Address

fn partial_cmp(&self, other: &Address) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Address) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Address) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Address) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Address) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Default for Address

fn default() -> Address

Construct a default Address filled with zeros.

impl PartialEq<Address> for Address

fn eq(&self, other: &Address) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Address) -> bool

This method tests for !=.

impl Debug for Address

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

Formats the value using the given formatter.

impl FromStr for Address

type Err = AddressError

The associated error which can be returned from parsing.

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

Parses a string into a valid Ethereum address.

Supported formats

• 0x prefixed address
• Raw bytes of an address represented by a bytes as an hexadecimal.

Examples

use clarity::Address;
// Method 1
Address::from_str("0x0102030405060708090a0b0c0d0e0f1011121314").unwrap();
// Method 1 (without 0x prefix)
Address::from_str("0102030405060708090a0b0c0d0e0f1011121314").unwrap();
// Method 2
let _address : Address = "14131211100f0e0d0c0b0a090807060504030201".parse().unwrap();

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,

Feeds a slice of this type into the given [Hasher].

impl LowerHex for Address

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

Formats the value using the given formatter.

impl UpperHex for Address

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

Formats the value using the given formatter.

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<'de> Deserialize<'de> for Address

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where     __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.