Struct alloy_primitives::Address

#[repr(transparent)]
pub struct Address(pub FixedBytes<20>);

An Ethereum address, 20 bytes in length.

This type is separate from B160 / FixedBytes<20> and is declared with the wrap_fixed_bytes! macro. This allows us to implement address-specific functionality.

The main difference with the generic FixedBytes implementation is that Display formats the address using its EIP-55 checksum (to_checksum). Use Debug to display the raw bytes without the checksum.

Examples

Parsing and formatting:

use alloy_primitives::{address, Address};

let checksummed = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045";
let expected = address!("d8da6bf26964af9d7eed9e03e53415d37aa96045");
let address = Address::parse_checksummed(checksummed, None).expect("valid checksum");
assert_eq!(address, expected);

// Format the address with the checksum
assert_eq!(address.to_string(), checksummed);
assert_eq!(address.to_checksum(None), checksummed);

// Format the compressed checksummed address
assert_eq!(format!("{address:#}"), "0xd8dA…6045");

// Format the address without the checksum
assert_eq!(format!("{address:?}"), "0xd8da6bf26964af9d7eed9e03e53415d37aa96045");

Tuple Fields

0: FixedBytes<20>

Implementations

impl Address

pub const ZERO: Self = _

Array of Zero bytes.

pub const fn new(bytes: [u8; 20]) -> Self

Wraps the given byte array in this type.

pub const fn with_last_byte(x: u8) -> Self

Creates a new byte array with the last byte set to x.

pub const fn repeat_byte(byte: u8) -> Self

Creates a new byte array where all bytes are set to byte.

pub const fn len_bytes() -> usize

Returns the size of this array in bytes.

pub fn random() -> Self

Instantiates a new fixed byte array with cryptographically random content.

Panics

This function panics if the underlying call to getrandom_uninit fails.

pub fn try_random() -> Result<Self, Error>

Tries to create a new fixed byte array with cryptographically random content.

Errors

This function only propagates the error from the underlying call to getrandom_uninit.

pub fn randomize(&mut self)

Fills this fixed byte array with cryptographically random content.

Panics

This function panics if the underlying call to getrandom_uninit fails.

pub fn try_randomize(&mut self) -> Result<(), Error>

Tries to fill this fixed byte array with cryptographically random content.

Errors

This function only propagates the error from the underlying call to getrandom_uninit.

pub fn random_with<R: Rng + ?Sized>(rng: &mut R) -> Self

Creates a new fixed byte array with the given random number generator.

pub fn randomize_with<R: Rng + ?Sized>(&mut self, rng: &mut R)

Fills this fixed byte array with the given random number generator.

pub fn from_slice(src: &[u8]) -> Self

Create a new fixed-hash from the given slice src.

Note

The given bytes are interpreted in big endian order.

Panics

If the length of src and the number of bytes in Self do not match.

pub const fn into_array(self) -> [u8; 20]

Returns the inner bytes array.

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

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

pub const fn const_eq(&self, other: &Self) -> bool

Compile-time equality. NOT constant-time equality.

pub const fn bit_and(self, rhs: Self) -> Self

Computes the bitwise AND of two FixedBytes.

pub const fn bit_or(self, rhs: Self) -> Self

Computes the bitwise OR of two FixedBytes.

pub const fn bit_xor(self, rhs: Self) -> Self

Computes the bitwise XOR of two FixedBytes.

impl Address

pub fn from_word(word: FixedBytes<32>) -> Self

Creates an Ethereum address from an EVM word’s upper 20 bytes (word[12..]).

Examples

let word = b256!("000000000000000000000000d8da6bf26964af9d7eed9e03e53415d37aa96045");
assert_eq!(
    Address::from_word(word),
    address!("d8da6bf26964af9d7eed9e03e53415d37aa96045")
);

pub fn into_word(&self) -> FixedBytes<32>

Left-pads the address to 32 bytes (EVM word size).

Examples

assert_eq!(
    address!("d8da6bf26964af9d7eed9e03e53415d37aa96045").into_word(),
    b256!("000000000000000000000000d8da6bf26964af9d7eed9e03e53415d37aa96045"),
);

pub fn parse_checksummed<S: AsRef<str>>( s: S, chain_id: Option<u64> ) -> Result<Self, AddressError>

Parse an Ethereum address, verifying its EIP-55 checksum.

You can optionally specify an EIP-155 chain ID to check the address using EIP-1191.

Errors

This method returns an error if the provided string does not match the expected checksum.

Examples

let checksummed = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045";
let address = Address::parse_checksummed(checksummed, None).unwrap();
let expected = address!("d8da6bf26964af9d7eed9e03e53415d37aa96045");
assert_eq!(address, expected);

pub fn to_checksum_raw<'a>( &self, buf: &'a mut [u8], chain_id: Option<u64> ) -> &'a str

Encodes an Ethereum address to its EIP-55 checksum.

You can optionally specify an EIP-155 chain ID to encode the address using EIP-1191.

Panics

This method panics if buf is not exactly 42 bytes long.

Examples

let address = address!("d8da6bf26964af9d7eed9e03e53415d37aa96045");
let mut buf = [0; 42];

let checksummed: &str = address.to_checksum_raw(&mut buf, None);
assert_eq!(checksummed, "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045");

let checksummed: &str = address.to_checksum_raw(&mut buf, Some(1));
assert_eq!(checksummed, "0xD8Da6bf26964Af9d7EEd9e03e53415d37AA96045");

pub fn to_checksum(&self, chain_id: Option<u64>) -> String

Encodes an Ethereum address to its EIP-55 checksum.

You can optionally specify an EIP-155 chain ID to encode the address using EIP-1191.

Examples

let address = address!("d8da6bf26964af9d7eed9e03e53415d37aa96045");

let checksummed: String = address.to_checksum(None);
assert_eq!(checksummed, "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045");

let checksummed: String = address.to_checksum(Some(1));
assert_eq!(checksummed, "0xD8Da6bf26964Af9d7EEd9e03e53415d37AA96045");

pub fn create(&self, nonce: u64) -> Self

Available on crate feature rlp only.

Computes the create address for this address and nonce:

keccak256(rlp([sender, nonce]))[12:]

Examples

let sender = address!("b20a608c624Ca5003905aA834De7156C68b2E1d0");

let expected = address!("00000000219ab540356cBB839Cbe05303d7705Fa");
assert_eq!(sender.create(0), expected);

let expected = address!("e33c6e89e69d085897f98e92b06ebd541d1daa99");
assert_eq!(sender.create(1), expected);

pub fn create2_from_code<S, C>(&self, salt: S, init_code: C) -> Selfwhere S: Borrow<[u8; 32]>, C: AsRef<[u8]>,

Computes the CREATE2 address of a smart contract as specified in EIP-1014:

keccak256(0xff ++ address ++ salt ++ keccak256(init_code))[12:]

The init_code is the code that, when executed, produces the runtime bytecode that will be placed into the state, and which typically is used by high level languages to implement a ‘constructor’.

Examples

let address = address!("8ba1f109551bD432803012645Ac136ddd64DBA72");
let salt = b256!("7c5ea36004851c764c44143b1dcb59679b11c9a68e5f41497f6cf3d480715331");
let init_code = bytes!("6394198df16000526103ff60206004601c335afa6040516060f3");
let expected = address!("533ae9d683B10C02EbDb05471642F85230071FC3");
assert_eq!(address.create2_from_code(salt, init_code), expected);

pub fn create2<S, H>(&self, salt: S, init_code_hash: H) -> Selfwhere S: Borrow<[u8; 32]>, H: Borrow<[u8; 32]>,

Computes the CREATE2 address of a smart contract as specified in EIP-1014, taking the pre-computed hash of the init code as input:

keccak256(0xff ++ address ++ salt ++ init_code_hash)[12:]

The init_code is the code that, when executed, produces the runtime bytecode that will be placed into the state, and which typically is used by high level languages to implement a ‘constructor’.

Examples

let address = address!("5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f");
let salt = b256!("2b2f5776e38002e0c013d0d89828fdb06fee595ea2d5ed4b194e3883e823e350");
let init_code_hash = b256!("96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f");
let expected = address!("0d4a11d5EEaaC28EC3F61d100daF4d40471f1852");
assert_eq!(address.create2(salt, init_code_hash), expected);

Methods from Deref<Target = FixedBytes<20>>

pub const ZERO: Self = _

pub fn randomize(&mut self)

Available on crate feature getrandom only.

Fills this FixedBytes with cryptographically random content.

Panics

This function panics if the underlying call to getrandom_uninit fails.

pub fn try_randomize(&mut self) -> Result<(), Error>

Available on crate feature getrandom only.

Tries to fill this FixedBytes with cryptographically random content.

Errors

This function only propagates the error from the underlying call to getrandom_uninit.

pub fn randomize_with<R: Rng + ?Sized>(&mut self, rng: &mut R)

Available on crate feature rand only.

Fills this FixedBytes with the given random number generator.

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

Returns a slice containing the entire array. Equivalent to &s[..].

pub fn as_mut_slice(&mut self) -> &mut [u8]

Returns a mutable slice containing the entire array. Equivalent to &mut s[..].

pub fn covers(&self, other: &Self) -> bool

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

pub fn const_eq(&self, other: &Self) -> bool

Compile-time equality. NOT constant-time equality.

pub fn is_zero(&self) -> bool

Returns true if no bits are set.

pub fn const_is_zero(&self) -> bool

Returns true if no bits are set.

Methods from Deref<Target = [u8; N]>

pub fn as_slice(&self) -> &[T]

Returns a slice containing the entire array. Equivalent to &s[..].

pub fn as_mut_slice(&mut self) -> &mut [T]

Returns a mutable slice containing the entire array. Equivalent to &mut s[..].

pub fn each_ref(&self) -> [&T; N]

🔬This is a nightly-only experimental API. (array_methods)

Borrows each element and returns an array of references with the same size as self.

Example

#![feature(array_methods)]

let floats = [3.1, 2.7, -1.0];
let float_refs: [&f64; 3] = floats.each_ref();
assert_eq!(float_refs, [&3.1, &2.7, &-1.0]);

This method is particularly useful if combined with other methods, like map. This way, you can avoid moving the original array if its elements are not Copy.

#![feature(array_methods)]

let strings = ["Ferris".to_string(), "♥".to_string(), "Rust".to_string()];
let is_ascii = strings.each_ref().map(|s| s.is_ascii());
assert_eq!(is_ascii, [true, false, true]);

// We can still access the original array: it has not been moved.
assert_eq!(strings.len(), 3);

pub fn each_mut(&mut self) -> [&mut T; N]

🔬This is a nightly-only experimental API. (array_methods)

Borrows each element mutably and returns an array of mutable references with the same size as self.

Example

#![feature(array_methods)]

let mut floats = [3.1, 2.7, -1.0];
let float_refs: [&mut f64; 3] = floats.each_mut();
*float_refs[0] = 0.0;
assert_eq!(float_refs, [&mut 0.0, &mut 2.7, &mut -1.0]);
assert_eq!(floats, [0.0, 2.7, -1.0]);

pub fn split_array_ref<const M: usize>(&self) -> (&[T; M], &[T])

🔬This is a nightly-only experimental API. (split_array)

Divides one array reference into two at an index.

The first will contain all indices from [0, M) (excluding the index M itself) and the second will contain all indices from [M, N) (excluding the index N itself).

Panics

Panics if M > N.

Examples

#![feature(split_array)]

let v = [1, 2, 3, 4, 5, 6];

{
   let (left, right) = v.split_array_ref::<0>();
   assert_eq!(left, &[]);
   assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
}

{
    let (left, right) = v.split_array_ref::<2>();
    assert_eq!(left, &[1, 2]);
    assert_eq!(right, &[3, 4, 5, 6]);
}

{
    let (left, right) = v.split_array_ref::<6>();
    assert_eq!(left, &[1, 2, 3, 4, 5, 6]);
    assert_eq!(right, &[]);
}

pub fn split_array_mut<const M: usize>(&mut self) -> (&mut [T; M], &mut [T])

🔬This is a nightly-only experimental API. (split_array)

Divides one mutable array reference into two at an index.

The first will contain all indices from [0, M) (excluding the index M itself) and the second will contain all indices from [M, N) (excluding the index N itself).

Panics

Panics if M > N.

Examples

#![feature(split_array)]

let mut v = [1, 0, 3, 0, 5, 6];
let (left, right) = v.split_array_mut::<2>();
assert_eq!(left, &mut [1, 0][..]);
assert_eq!(right, &mut [3, 0, 5, 6]);
left[1] = 2;
right[1] = 4;
assert_eq!(v, [1, 2, 3, 4, 5, 6]);

pub fn rsplit_array_ref<const M: usize>(&self) -> (&[T], &[T; M])

🔬This is a nightly-only experimental API. (split_array)

Divides one array reference into two at an index from the end.

The first will contain all indices from [0, N - M) (excluding the index N - M itself) and the second will contain all indices from [N - M, N) (excluding the index N itself).

Panics

Panics if M > N.

Examples

#![feature(split_array)]

let v = [1, 2, 3, 4, 5, 6];

{
   let (left, right) = v.rsplit_array_ref::<0>();
   assert_eq!(left, &[1, 2, 3, 4, 5, 6]);
   assert_eq!(right, &[]);
}

{
    let (left, right) = v.rsplit_array_ref::<2>();
    assert_eq!(left, &[1, 2, 3, 4]);
    assert_eq!(right, &[5, 6]);
}

{
    let (left, right) = v.rsplit_array_ref::<6>();
    assert_eq!(left, &[]);
    assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
}

pub fn rsplit_array_mut<const M: usize>(&mut self) -> (&mut [T], &mut [T; M])

🔬This is a nightly-only experimental API. (split_array)

Divides one mutable array reference into two at an index from the end.

The first will contain all indices from [0, N - M) (excluding the index N - M itself) and the second will contain all indices from [N - M, N) (excluding the index N itself).

Panics

Panics if M > N.

Examples

#![feature(split_array)]

let mut v = [1, 0, 3, 0, 5, 6];
let (left, right) = v.rsplit_array_mut::<4>();
assert_eq!(left, &mut [1, 0]);
assert_eq!(right, &mut [3, 0, 5, 6][..]);
left[1] = 2;
right[1] = 4;
assert_eq!(v, [1, 2, 3, 4, 5, 6]);

pub fn as_ascii(&self) -> Option<&[AsciiChar; N]>

🔬This is a nightly-only experimental API. (ascii_char)

Converts this array of bytes into a array of ASCII characters, or returns None if any of the characters is non-ASCII.

Examples

#![feature(ascii_char)]
#![feature(const_option)]

const HEX_DIGITS: [std::ascii::Char; 16] =
    *b"0123456789abcdef".as_ascii().unwrap();

assert_eq!(HEX_DIGITS[1].as_str(), "1");
assert_eq!(HEX_DIGITS[10].as_str(), "a");

pub unsafe fn as_ascii_unchecked(&self) -> &[AsciiChar; N]

🔬This is a nightly-only experimental API. (ascii_char)

Converts this array of bytes into a array of ASCII characters, without checking whether they’re valid.

Safety

Every byte in the array must be in 0..=127, or else this is UB.

Trait Implementations

impl<'a> Arbitrary<'a> for Address

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl Arbitrary for Address

type Parameters = <FixedBytes<20> as Arbitrary>::Parameters

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = Map<<FixedBytes<20> as Arbitrary>::Strategy, fn(_: FixedBytes<20>) -> Address>

The type of Strategy used to generate values of type Self.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

impl AsMut<[u8]> for Address

fn as_mut(&mut self) -> &mut [u8]

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsMut<[u8; 20]> for Address

fn as_mut(&mut self) -> &mut [u8; 20]

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsMut<FixedBytes<20>> for Address

fn as_mut(&mut self) -> &mut FixedBytes<20>

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<[u8]> for Address

fn as_ref(&self) -> &[u8]

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<[u8; 20]> for Address

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

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<FixedBytes<20>> for Address

fn as_ref(&self) -> &FixedBytes<20>

Converts this type into a shared reference of the (usually inferred) input type.

impl BitAnd for Address

type Output = Address

The resulting type after applying the & operator.

fn bitand(self, rhs: Address) -> Address

Performs the & operation.

impl BitAndAssign for Address

fn bitand_assign(&mut self, rhs: Address)

Performs the &= operation.

impl BitOr for Address

type Output = Address

The resulting type after applying the | operator.

fn bitor(self, rhs: Address) -> Address

Performs the | operation.

impl BitOrAssign for Address

fn bitor_assign(&mut self, rhs: Address)

Performs the |= operation.

impl BitXor for Address

type Output = Address

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Address) -> Address

Performs the ^ operation.

impl BitXorAssign for Address

fn bitxor_assign(&mut self, rhs: Address)

Performs the ^= operation.

impl Borrow<[u8]> for &Address

fn borrow(&self) -> &[u8]

Immutably borrows from an owned value.

impl Borrow<[u8]> for &mut Address

fn borrow(&self) -> &[u8]

Immutably borrows from an owned value.

impl Borrow<[u8]> for Address

fn borrow(&self) -> &[u8]

Immutably borrows from an owned value.

impl Borrow<[u8; 20]> for &Address

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

Immutably borrows from an owned value.

impl Borrow<[u8; 20]> for &mut Address

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

Immutably borrows from an owned value.

impl Borrow<[u8; 20]> for Address

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

Immutably borrows from an owned value.

impl BorrowMut<[u8]> for &mut Address

fn borrow_mut(&mut self) -> &mut [u8]

Mutably borrows from an owned value.

impl BorrowMut<[u8]> for Address

fn borrow_mut(&mut self) -> &mut [u8]

Mutably borrows from an owned value.

impl BorrowMut<[u8; 20]> for &mut Address

fn borrow_mut(&mut self) -> &mut [u8; 20]

Mutably borrows from an owned value.

impl BorrowMut<[u8; 20]> for Address

fn borrow_mut(&mut self) -> &mut [u8; 20]

Mutably borrows from an owned value.

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 Decodable for Address

fn decode(buf: &mut &[u8]) -> Result<Self>

Decodes the blob into the appropriate type. buf must be advanced past the decoded object.

impl Default for Address

fn default() -> Address

Returns the “default value” for a type.

impl Deref for Address

type Target = FixedBytes<20>

The resulting type after dereferencing.

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

Dereferences the value.

impl DerefMut for Address

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de> Deserialize<'de> for Address

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

Deserialize this value from the given Serde deserializer.

impl Display for Address

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

Formats the value using the given formatter.

impl Distribution<Address> for Standard

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Address

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T> where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

impl Encodable for Address

fn length(&self) -> usize

Returns the length of the encoding of this type in bytes.

fn encode(&self, out: &mut dyn BufMut)

Encodes the type into the out buffer.

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

fn from(value: &'a [u8; 20]) -> &'a Address

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

fn from(value: &'a Address) -> &'a [u8; 20]

Converts to this type from the input type.

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

fn from(value: &'a mut [u8; 20]) -> &'a Address

Converts to this type from the input type.

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

fn from(value: &'a mut [u8; 20]) -> &'a mut Address

Converts to this type from the input type.

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

fn from(value: &'a mut [u8; 20]) -> Self

Converts to this type from the input type.

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

fn from(value: &'a mut Address) -> &'a [u8; 20]

Converts to this type from the input type.

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

fn from(value: &'a mut Address) -> &'a mut [u8; 20]

Converts to this type from the input type.

impl From<[u8; 20]> for Address

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

Converts to this type from the input type.

impl From<Address> for [u8; 20]

fn from(value: Address) -> Self

Converts to this type from the input type.

impl From<Address> for FixedBytes<20>

fn from(original: Address) -> Self

Converts to this type from the input type.

impl From<Address> for U160

fn from(value: Address) -> Self

Converts to this type from the input type.

impl From<FixedBytes<20>> for Address

fn from(original: FixedBytes<20>) -> Address

Converts to this type from the input type.

impl From<Uint<160, 3>> for Address

fn from(value: U160) -> Self

Converts to this type from the input type.

impl FromHex for Address

type Error = FromHexError

fn from_hex<T>(hex: T) -> Result<Self, Self::Error>where T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails with a custom error type.

impl FromStr for Address

type Err = <FixedBytes<20> as FromStr>::Err

The associated error which can be returned from parsing.

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

Parses a string s to return a value of this 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<__IdxT> Index<__IdxT> for Addresswhere FixedBytes<20>: Index<__IdxT>,

type Output = <FixedBytes<20> as Index<__IdxT>>::Output

The returned type after indexing.

fn index(&self, idx: __IdxT) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<__IdxT> IndexMut<__IdxT> for Addresswhere FixedBytes<20>: IndexMut<__IdxT>,

fn index_mut(&mut self, idx: __IdxT) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'__deriveMoreLifetime> IntoIterator for &'__deriveMoreLifetime Address

type Item = <&'__deriveMoreLifetime FixedBytes<20> as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <&'__deriveMoreLifetime FixedBytes<20> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'__deriveMoreLifetime> IntoIterator for &'__deriveMoreLifetime mut Address

type Item = <&'__deriveMoreLifetime mut FixedBytes<20> as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <&'__deriveMoreLifetime mut FixedBytes<20> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl IntoIterator for Address

type Item = <FixedBytes<20> as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <FixedBytes<20> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl LowerHex for Address

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

Formats the value using the given formatter.

impl MaxEncodedLenAssoc for Address

const LEN: usize = 21usize

The maximum length.

impl Ord for Address

fn cmp(&self, other: &Address) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq<&[u8]> for Address

fn eq(&self, other: &&[u8]) -> 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<&[u8; 20]> for Address

fn eq(&self, other: &&[u8; 20]) -> 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<&Address> for [u8]

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 PartialEq<&Address> for [u8; 20]

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 PartialEq<[u8]> for &Address

fn eq(&self, other: &[u8]) -> 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<[u8]> for Address

fn eq(&self, other: &[u8]) -> 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<[u8; 20]> for &Address

fn eq(&self, other: &[u8; 20]) -> 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<[u8; 20]> for Address

fn eq(&self, other: &[u8; 20]) -> 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<Address> for &[u8]

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 PartialEq<Address> for &[u8; 20]

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 PartialEq<Address> for [u8]

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 PartialEq<Address> for [u8; 20]

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 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 PartialOrd<&[u8]> for Address

fn partial_cmp(&self, other: &&[u8]) -> Option<Ordering>

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

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

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

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

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

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

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

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

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

impl PartialOrd<&Address> for [u8]

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

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

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

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

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

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

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

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

impl PartialOrd<[u8]> for &Address

fn partial_cmp(&self, other: &[u8]) -> Option<Ordering>

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

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

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

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

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

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

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

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

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

impl PartialOrd<[u8]> for Address

fn partial_cmp(&self, other: &[u8]) -> Option<Ordering>

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

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

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

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

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

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

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

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

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

impl PartialOrd<Address> for &[u8]

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

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

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

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

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

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

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

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

impl PartialOrd<Address> for [u8]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Serialize for Address

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

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

type Error = TryFromSliceError

The type returned in the event of a conversion error.

fn try_from(slice: &'a [u8]) -> Result<&'a Address, Self::Error>

Performs the conversion.

impl TryFrom<&[u8]> for Address

type Error = TryFromSliceError

The type returned in the event of a conversion error.

fn try_from(slice: &[u8]) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> TryFrom<&'a mut [u8]> for &'a mut Address

type Error = TryFromSliceError

The type returned in the event of a conversion error.

fn try_from(slice: &'a mut [u8]) -> Result<&'a mut Address, Self::Error>

Performs the conversion.

impl TryFrom<&mut [u8]> for Address

type Error = TryFromSliceError

The type returned in the event of a conversion error.

fn try_from(slice: &mut [u8]) -> Result<Self, Self::Error>

Performs the conversion.

impl UpperHex for Address

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

Formats the value using the given formatter.

impl Copy for Address

impl Eq for Address

impl MaxEncodedLen<{ $len }> for Address

impl StructuralEq for Address

impl StructuralPartialEq for Address