Struct dcl_crypto::account::Address

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

Implementations

impl Address

pub fn zero() -> Self

Creates an instance of the zero address

  use dcl_crypto::account::Address;
  assert_eq!(Address::zero().to_string(), "0x0000000000000000000000000000000000000000")

pub fn checksum(&self) -> String

Calculate ERC-55 version of the address

    use dcl_crypto::account::Address;
    assert_eq!(Address::try_from("0x0f5d2fb29fb7d3cfee444a200298f468908cc942").unwrap().checksum(), "0x0F5D2fB29fb7d3CFeE444a200298f468908cC942");
    assert_eq!(Address::try_from("0x554bb6488ba955377359bed16b84ed0822679cdc").unwrap().checksum(), "0x554BB6488bA955377359bED16b84Ed0822679CDC");
    assert_eq!(Address::try_from("0x1784ef41af86e97f8d28afe95b573a24aeda966e").unwrap().checksum(), "0x1784Ef41af86e97f8D28aFe95b573a24aEDa966e");
    assert_eq!(Address::from([255; 20]).checksum(), "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF");
    assert_eq!(Address::from([0; 20]).checksum(), "0x0000000000000000000000000000000000000000");

Methods from Deref<Target = H160>

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

Extracts a byte slice containing the entire fixed hash.

pub fn as_fixed_bytes(&self) -> &[u8; 20]

Extracts a reference to the byte array containing the entire fixed hash.

pub fn as_ptr(&self) -> *const u8

Returns a constant raw pointer to the value.

pub fn covers(&self, b: &H160) -> bool

Returns true if all bits set in b are also set in self.

pub fn is_zero(&self) -> bool

Returns true if no bits are set.

pub fn to_low_u64_be(&self) -> u64

Returns the lowest 8 bytes interpreted as big-endian.

Note

For hash type with less than 8 bytes the missing bytes are interpreted as being zero.

pub fn to_low_u64_le(&self) -> u64

Returns the lowest 8 bytes interpreted as little-endian.

Note

For hash type with less than 8 bytes the missing bytes are interpreted as being zero.

pub fn to_low_u64_ne(&self) -> u64

Returns the lowest 8 bytes interpreted as native-endian.

Note

For hash type with less than 8 bytes the missing bytes are interpreted as being zero.

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() -> Address

Returns the “default value” for a type.

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.

impl Display for Address

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

Format an Address into it string representation

  use dcl_crypto::account::Address;
  assert_eq!(Address::from([0; 20]).to_string(), "0x0000000000000000000000000000000000000000");
  assert_eq!(Address::from([255; 20]).to_string(), "0xffffffffffffffffffffffffffffffffffffffff");

impl From<[u8; 20]> for Address

fn from(value: [u8; 20]) -> Self

Converts [u8; 20] into an Address

  use dcl_crypto::account::Address;

  let address = Address::from([0; 20]);
  assert_eq!(address.to_string(), "0x0000000000000000000000000000000000000000")

impl From<Address> for String

fn from(value: Address) -> Self

Formats an Address into its String representation

impl From<H160> for Address

fn from(value: H160) -> Self

Converts an H160 into an Address

  use web3::types::H160;
  use dcl_crypto::account::Address;

  let address = Address::from(H160([0; 20]));
  assert_eq!(address.to_string(), "0x0000000000000000000000000000000000000000")

impl LowerHex for Address

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

Formats the Address into its hexadecimal lowercase representation

    use dcl_crypto::account::Address;
    let address = Address::from([255; 20]);
    let zero = Address::from([0; 20]);

    assert_eq!(format!("{zero:x}"), "0000000000000000000000000000000000000000");
    assert_eq!(format!("{address:x}"), "ffffffffffffffffffffffffffffffffffffffff");

    assert_eq!(format!("{zero:#x}"), "0x0000000000000000000000000000000000000000");
    assert_eq!(format!("{address:#x}"), "0xffffffffffffffffffffffffffffffffffffffff");

impl PartialEq<H160> for &Address

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<H160> for Address

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq 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: &Rhs) -> bool

This method 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 TryFrom<&str> for Address

fn try_from(value: &str) -> Result<Self, Self::Error>

Converts an hexadecimal representation into an Address

  use dcl_crypto::account::Address;

  let lower_address = Address::try_from("0xf15fd08462c3248b2bfe9c39b48af7801fc303db");
  let upper_address = Address::try_from("0xF15FD08462C3248B2BFE9C39B48AF7801FC303DB");
  let address_expected: [u8; 20] = [ 241, 95, 208, 132, 98, 195, 36, 139, 43, 254, 156, 57, 180, 138, 247, 128, 31, 195, 3, 219];
  assert_eq!(lower_address.unwrap(), Address::from(address_expected));
  assert_eq!(upper_address.unwrap(), Address::from(address_expected));

It requires the address string to be prefixed with 0x

  use dcl_crypto::account::{Address, DecodeHexError};

  let not_prefixed_address = Address::try_from("f15fd08462c3248b2bfe9c39b48af7801fc303db");
  assert_eq!(not_prefixed_address.is_err(), true);
  assert_eq!(not_prefixed_address, Err(DecodeHexError::MissingPrefix));

It requires the address to be 42 characters long

  use dcl_crypto::account::{Address, DecodeHexError};

  let len_41_address = Address::try_from("0xf15fd08462c3248b2bfe9c39b48af7801fc303d");
  assert_eq!(len_41_address.is_err(), true);
  assert_eq!(len_41_address, Err(DecodeHexError::InvalidLength));

  let len_43_address = Address::try_from("0xf15fd08462c3248b2bfe9c39b48af7801fc303dbb");
  assert_eq!(len_43_address.is_err(), true);
  assert_eq!(len_43_address, Err(DecodeHexError::InvalidLength));

It requires all characters to be hexadecimals

  use dcl_crypto::account::{Address, DecodeHexError};

  let not_hex_address = Address::try_from("0xf15fd08462c3248b2bfe9c39b48af7801fc303dx");
  assert_eq!(not_hex_address.is_err(), true);
  assert_eq!(not_hex_address, Err(DecodeHexError::InvalidHexCharacter{ c: 'x', index: 41}));

type Error = DecodeHexError

The type returned in the event of a conversion error.

impl TryFrom<String> for Address

type Error = DecodeHexError

The type returned in the event of a conversion error.

fn try_from(value: String) -> Result<Self, Self::Error>

Performs the conversion.

impl UpperHex for Address

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

Formats the Address into its hexadecimal uppercase representation

    use dcl_crypto::account::Address;
    let address = Address::from([255; 20]);
    let zero = Address::from([0; 20]);

    assert_eq!(format!("{zero:X}"), "0000000000000000000000000000000000000000");
    assert_eq!(format!("{address:X}"), "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");

    assert_eq!(format!("{zero:#X}"), "0X0000000000000000000000000000000000000000");
    assert_eq!(format!("{address:#X}"), "0XFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");

impl Deref for Address

type Target = H160

The resulting type after dereferencing.

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

Dereferences the value.

impl Copy for Address

impl StructuralPartialEq for Address