Struct AllocationId

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

A unique identifier for an allocation: the allocation’s Ethereum address.

This is a “new-type” wrapper around Address to provide type safety.

Formatting

The AllocationId type implements the following formatting traits:

• Use std::fmt::Display for formatting the AllocationId as an EIP-55 checksum string.
• Use std::fmt::LowerHex (or std::fmt::UpperHex) for formatting the AllocationId as a hexadecimal string.

See the Display, LowerHex, and UpperHex trait implementations for usage examples.

Generating test data

The AllocationId type implements the fake crate’s fake::Dummy trait, allowing you to generate random AllocationId values for testing.

Note that the fake feature must be enabled to use this functionality.

See the Dummy trait impl for usage examples.

Implementations

impl AllocationId

pub const fn new(address: Address) -> Self

Create a new AllocationId.

pub fn into_inner(self) -> Address

Return the internal representation.

Methods from Deref<Target = Address>

pub const ZERO: Address

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

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

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

Compile-time equality. NOT constant-time equality.

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

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

Examples

assert_eq!(
    address!("0xd8da6bf26964af9d7eed9e03e53415d37aa96045").into_word(),
    b256!("0x000000000000000000000000d8da6bf26964af9d7eed9e03e53415d37aa96045"),
);

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

Encodes an Ethereum address to its EIP-55 checksum into a heap-allocated string.

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

Examples

let address = address!("0xd8da6bf26964af9d7eed9e03e53415d37aa96045");

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 to_checksum_raw<'a>( &self, buf: &'a mut [u8], chain_id: Option<u64>, ) -> &'a mut str

Encodes an Ethereum address to its EIP-55 checksum into the given buffer.

For convenience, the buffer is returned as a &mut str, as the bytes are guaranteed to be valid UTF-8.

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

Panics

Panics if buf is not exactly 42 bytes long.

Examples

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

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

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

pub fn to_checksum_buffer(&self, chain_id: Option<u64>) -> AddressChecksumBuffer

Encodes an Ethereum address to its EIP-55 checksum into a stack-allocated buffer.

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

Examples

let address = address!("0xd8da6bf26964af9d7eed9e03e53415d37aa96045");

let mut buffer: AddressChecksumBuffer = address.to_checksum_buffer(None);
assert_eq!(buffer.as_str(), "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045");

let checksummed: &str = buffer.format(&address, Some(1));
assert_eq!(checksummed, "0xD8Da6bf26964Af9d7EEd9e03e53415d37AA96045");

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

Computes the create address for this address and nonce:

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

Examples

let sender = address!("0xb20a608c624Ca5003905aA834De7156C68b2E1d0");

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

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

pub fn create2_from_code<S, C>(&self, salt: S, init_code: C) -> Address

where 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!("0x8ba1f109551bD432803012645Ac136ddd64DBA72");
let salt = b256!("0x7c5ea36004851c764c44143b1dcb59679b11c9a68e5f41497f6cf3d480715331");
let init_code = bytes!("6394198df16000526103ff60206004601c335afa6040516060f3");
let expected = address!("0x533ae9d683B10C02EbDb05471642F85230071FC3");
assert_eq!(address.create2_from_code(salt, init_code), expected);

pub fn create2<S, H>(&self, salt: S, init_code_hash: H) -> Address

where 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!("0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f");
let salt = b256!("0x2b2f5776e38002e0c013d0d89828fdb06fee595ea2d5ed4b194e3883e823e350");
let init_code_hash =
    b256!("0x96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f");
let expected = address!("0x0d4a11d5EEaaC28EC3F61d100daF4d40471f1852");
assert_eq!(address.create2(salt, init_code_hash), expected);

pub fn create_eof<S>(&self, salt: S) -> Address

where S: Borrow<[u8; 32]>,

Computes the address created by the EOFCREATE opcode, where self is the sender.

The address is calculated as keccak256(0xff || sender32 || salt)[12:], where sender32 is the sender address left-padded to 32 bytes with zeros.

See EIP-7620 for more details.

This function's stability is not guaranteed. It may change in the future as the EIP is not yet accepted.

Examples

let address = address!("0xb20a608c624Ca5003905aA834De7156C68b2E1d0");
let salt = b256!("0x7c5ea36004851c764c44143b1dcb59679b11c9a68e5f41497f6cf3d480715331");
// Create an address using CREATE_EOF
let eof_address = address.create_eof(salt);

Methods from Deref<Target = FixedBytes<20>>

pub const ZERO: FixedBytes<N>

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

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

pub fn const_eq(&self, other: &FixedBytes<N>) -> 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_ascii(&self) -> Option<&[AsciiChar; N]>

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

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

Examples

#![feature(ascii_char)]

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 an 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.

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]

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

Example

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.

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]

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

Example

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]);

Trait Implementations

impl AsRef<Address> for AllocationId

fn as_ref(&self) -> &Address

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

impl Clone for AllocationId

fn clone(&self) -> AllocationId

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AllocationId

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

Formats the AllocationId using its raw lower-case hexadecimal representation.

It is advised to use the LowerHex (and UpperHex) format trait implementation over the Debug implementation to format the AllocationId as a lower-case hexadecimal string.

This implementation matches alloy_primitives::Address’s Debug implementation.

const ID: AllocationId = allocation_id!("0002c67268fb8c8917f36f865a0cbdf5292fa68d");

assert_eq!(format!("{:?}", ID), "0x0002c67268fb8c8917f36f865a0cbdf5292fa68d");

impl Deref for AllocationId

type Target = Address

The resulting type after dereferencing.

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

Dereferences the value.

impl<'de> Deserialize<'de> for AllocationId

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for AllocationId

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

Formats the AllocationId using its EIP-55 checksum representation.

See LowerHex (and UpperHex) for formatting the AllocationId as a hexadecimal string.

const ID: AllocationId = allocation_id!("0002c67268fb8c8917f36f865a0cbdf5292fa68d");

// Note the uppercase and lowercase hex characters in the checksum
assert_eq!(format!("{}", ID), "0x0002c67268FB8C8917F36F865a0CbdF5292FA68d");

impl Dummy<Faker> for AllocationId

To use the fake crate to generate random AllocationId values, the fake feature must be enabled.

let allocation_id = fake::Faker.fake::<AllocationId>();

println!("AllocationId: {:#x}", allocation_id);

fn dummy_with_rng<R: Rng + ?Sized>(_: &Faker, rng: &mut R) -> Self

Generate a dummy value for a given type using a random number generator.

fn dummy(config: &T) -> Self

Generate a dummy value for a type.

impl From<Address> for AllocationId

fn from(address: Address) -> Self

Converts to this type from the input type.

impl From<AllocationId> for CollectionId

Convert an AllocationId into a CollectionId by zero padding the allocation id to 32 bytes.

use thegraph_core::{
    alloy::primitives::Address,
    alloy::primitives::address,
    collection_id, CollectionId,
    allocation_id, AllocationId
};

let allocation_id: AllocationId = allocation_id!("3e1f9c2aB4C7F1b3d7E839EbE6Ae451c8A0b1d24");
let collection_id: CollectionId = allocation_id.into();
assert_eq!(format!("{:?}", collection_id), "0x0000000000000000000000003e1f9c2ab4c7f1b3d7e839ebe6ae451c8a0b1d24");

let collection_id2: CollectionId = CollectionId::from(allocation_id!("3e1f9c2aB4C7F1b3d7E839EbE6Ae451c8A0b1d24"));
assert_eq!(format!("{:?}", collection_id2), "0x0000000000000000000000003e1f9c2ab4c7f1b3d7e839ebe6ae451c8a0b1d24");

fn from(allocation: AllocationId) -> Self

Converts to this type from the input type.

impl From<CollectionId> for AllocationId

Convert a CollectionId into an AllocationId by truncating to the last 20 bytes.

use thegraph_core::{
    alloy::primitives::Address,
    alloy::primitives::address,
    collection_id, CollectionId,
    allocation_id, AllocationId
};

let collection_id: CollectionId = collection_id!("0000000000000000000000003e1f9c2ab4c7f1b3d7e839ebe6ae451c8a0b1d24");
let allocation_id: AllocationId = collection_id.into();
assert_eq!(format!("{:?}", allocation_id), "0x3e1f9c2ab4c7f1b3d7e839ebe6ae451c8a0b1d24");

let allocation_id2: AllocationId = AllocationId::from(collection_id!("0000000000000000000000003e1f9c2ab4c7f1b3d7e839ebe6ae451c8a0b1d24"));
assert_eq!(format!("{:?}", allocation_id2), "0x3e1f9c2ab4c7f1b3d7e839ebe6ae451c8a0b1d24");

fn from(collection_id: CollectionId) -> Self

Converts to this type from the input type.

impl FromStr for AllocationId

type Err = <Address as FromStr>::Err

The associated error which can be returned from parsing.

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

Parses a string s to return a value of this type.

impl Hash for AllocationId

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 LowerHex for AllocationId

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

Lowercase hex representation of the AllocationId.

Note that the alternate flag, #, adds a 0x in front of the output.

const ID: AllocationId = allocation_id!("0002c67268fb8c8917f36f865a0cbdf5292fa68d");

// Lower hex
assert_eq!(format!("{:x}", ID), "0002c67268fb8c8917f36f865a0cbdf5292fa68d");

// Lower hex with alternate flag
assert_eq!(format!("{:#x}", ID), "0x0002c67268fb8c8917f36f865a0cbdf5292fa68d");

impl Ord for AllocationId

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq<Address> for AllocationId

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

fn eq(&self, other: &AllocationId) -> 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 PartialOrd for AllocationId

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl Serialize for AllocationId

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl UpperHex for AllocationId

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

Uppercase hex representation of the AllocationId.

Note that the alternate flag, #, adds a 0x in front of the output.

const ID: AllocationId = allocation_id!("0002c67268fb8c8917f36f865a0cbdf5292fa68d");

// Upper hex
assert_eq!(format!("{:X}", ID), "0002C67268FB8C8917F36F865A0CBDF5292FA68D");

// Upper hex with alternate flag
assert_eq!(format!("{:#X}", ID), "0x0002C67268FB8C8917F36F865A0CBDF5292FA68D");

impl Copy for AllocationId

impl Eq for AllocationId

impl StructuralPartialEq for AllocationId