reth::primitives::arbitrary

Trait Arbitrary

pub trait Arbitrary<'a>: Sized {
    // Required method
    fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self, Error>;

    // Provided methods
    fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error> { ... }
    fn size_hint(depth: usize) -> (usize, Option<usize>) { ... }
    fn try_size_hint(
        depth: usize,
    ) -> Result<(usize, Option<usize>), MaxRecursionReached> { ... }
}
Expand description

Generate arbitrary structured values from raw, unstructured data.

The Arbitrary trait allows you to generate valid structured values, like HashMaps, or ASTs, or MyTomlConfig, or any other data structure from raw, unstructured bytes provided by a fuzzer.

§Deriving Arbitrary

Automatically deriving the Arbitrary trait is the recommended way to implement Arbitrary for your types.

Using the custom derive requires that you enable the "derive" cargo feature in your Cargo.toml:

[dependencies]
arbitrary = { version = "1", features = ["derive"] }

Then, you add the #[derive(Arbitrary)] annotation to your struct or enum type definition:

use arbitrary::Arbitrary;
use std::collections::HashSet;

#[derive(Arbitrary)]
pub struct AddressBook {
    friends: HashSet<Friend>,
}

#[derive(Arbitrary, Hash, Eq, PartialEq)]
pub enum Friend {
    Buddy { name: String },
    Pal { age: usize },
}

Every member of the struct or enum must also implement Arbitrary.

It is also possible to change the default bounds added by the derive:

use arbitrary::Arbitrary;

trait Trait {
    type Assoc: for<'a> Arbitrary<'a>;
}

#[derive(Arbitrary)]
// The bounds are used verbatim, so any existing trait bounds will need to be repeated.
#[arbitrary(bound = "T: Trait")]
struct Point<T: Trait> {
    x: T::Assoc,
}

§Implementing Arbitrary By Hand

Implementing Arbitrary mostly involves nested calls to other Arbitrary arbitrary implementations for each of your struct or enum’s members. But sometimes you need some amount of raw data, or you need to generate a variably-sized collection type, or something of that sort. The Unstructured type helps you with these tasks.

use arbitrary::{Arbitrary, Result, Unstructured};

impl<'a, T> Arbitrary<'a> for MyCollection<T>
where
    T: Arbitrary<'a>,
{
    fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
        // Get an iterator of arbitrary `T`s.
        let iter = u.arbitrary_iter::<T>()?;

        // And then create a collection!
        let mut my_collection = MyCollection::new();
        for elem_result in iter {
            let elem = elem_result?;
            my_collection.insert(elem);
        }

        Ok(my_collection)
    }
}

§A Note On Output Distributions

There is no requirement for a particular distribution of the values. For example, it is not required that every value appears with the same probability. That being said, the main use for Arbitrary is for fuzzing, so in many cases a uniform distribution will make the most sense in order to provide the best coverage of the domain. In other cases this is not desirable or even possible, for example when sampling from a uniform distribution is computationally expensive or in the case of collections that may grow indefinitely.

Required Methods§

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

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

Calling Arbitrary::arbitrary requires that you have some raw data, perhaps given to you by a fuzzer like AFL or libFuzzer. You wrap this raw data in an Unstructured, and then you can call <MyType as Arbitrary>::arbitrary to construct an arbitrary instance of MyType from that unstructured data.

Implementations may return an error if there is not enough data to construct a full instance of Self, or they may fill out the rest of Self with dummy values. Using dummy values when the underlying data is exhausted can help avoid accidentally “defeating” some of the fuzzer’s mutations to the underlying byte stream that might otherwise lead to interesting runtime behavior or new code coverage if only we had just a few more bytes. However, it also requires that implementations for recursive types (e.g. struct Foo(Option<Box<Foo>>)) avoid infinite recursion when the underlying data is exhausted.

use arbitrary::{Arbitrary, Unstructured};

#[derive(Arbitrary)]
pub struct MyType {
    // ...
}

// Get the raw data from the fuzzer or wherever else.
let raw_data: &[u8] = get_raw_data_from_fuzzer();

// Wrap that raw data in an `Unstructured`.
let mut unstructured = Unstructured::new(raw_data);

// Generate an arbitrary instance of `MyType` and do stuff with it.
if let Ok(value) = MyType::arbitrary(&mut unstructured) {
    do_stuff(value);
}

See also the documentation for Unstructured.

Provided Methods§

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

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

This is similar to Arbitrary::arbitrary, however it assumes that it is the last consumer of the given data, and is thus able to consume it all if it needs. See also the documentation for Unstructured.

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.

This is useful for determining how many elements we should insert when creating an arbitrary collection.

The return value is similar to Iterator::size_hint: it returns a tuple where the first element is a lower bound on the number of bytes required, and the second element is an optional upper bound.

The default implementation return (0, None) which is correct for any type, but not ultimately that useful. Using #[derive(Arbitrary)] will create a better implementation. If you are writing an Arbitrary implementation by hand, and your type can be part of a dynamically sized collection (such as Vec), you are strongly encouraged to override this default with a better implementation, and also override try_size_hint.

§How to implement this

If the size hint calculation is a trivial constant and does not recurse into any other size_hint call, you should implement it in size_hint:

use arbitrary::{size_hint, Arbitrary, Result, Unstructured};

struct SomeStruct(u8);

impl<'a> Arbitrary<'a> for SomeStruct {
    fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
        let buf = &mut [0];
        u.fill_buffer(buf)?;
        Ok(SomeStruct(buf[0]))
    }

    #[inline]
    fn size_hint(depth: usize) -> (usize, Option<usize>) {
        let _ = depth;
        (1, Some(1))
    }
}

Otherwise, it should instead be implemented in try_size_hint, and the size_hint implementation should forward to it:

use arbitrary::{size_hint, Arbitrary, MaxRecursionReached, Result, Unstructured};

struct SomeStruct<A, B> {
    a: A,
    b: B,
}

impl<'a, A: Arbitrary<'a>, B: Arbitrary<'a>> Arbitrary<'a> for SomeStruct<A, B> {
    fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
        // ...
    }

    fn size_hint(depth: usize) -> (usize, Option<usize>) {
        // Return the value of try_size_hint
        //
        // If the recursion fails, return the default, always valid `(0, None)`
        Self::try_size_hint(depth).unwrap_or_default()
    }

    fn try_size_hint(depth: usize) -> Result<(usize, Option<usize>), MaxRecursionReached> {
        // Protect against potential infinite recursion with
        // `try_recursion_guard`.
        size_hint::try_recursion_guard(depth, |depth| {
            // If we aren't too deep, then `recursion_guard` calls
            // this closure, which implements the natural size hint.
            // Don't forget to use the new `depth` in all nested
            // `try_size_hint` calls! We recommend shadowing the
            // parameter, like what is done here, so that you can't
            // accidentally use the wrong depth.
            Ok(size_hint::and(
                <A as Arbitrary>::try_size_hint(depth)?,
                <B as Arbitrary>::try_size_hint(depth)?,
            ))
        })
    }
}
§Invariant

It must be possible to construct every possible output using only inputs of lengths bounded by these parameters. This applies to both Arbitrary::arbitrary and Arbitrary::arbitrary_take_rest.

This is trivially true for (0, None). To restrict this further, it must be proven that all inputs that are now excluded produced redundant outputs which are still possible to produce using the reduced input space.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

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

Unlike size_hint, this function keeps the information that the recursion limit was reached. This is required to “short circuit” the calculation and avoid exponential blowup with recursive structures.

If you are implementing size_hint for a struct that could be recursive, you should implement try_size_hint and call the try_size_hint when recursing

The return value is similar to core::iter::Iterator::size_hint: it returns a tuple where the first element is a lower bound on the number of bytes required, and the second element is an optional upper bound.

The default implementation returns the value of size_hint which is correct for any type, but might lead to exponential blowup when dealing with recursive types.

§Invariant

It must be possible to construct every possible output using only inputs of lengths bounded by these parameters. This applies to both Arbitrary::arbitrary and Arbitrary::arbitrary_take_rest.

This is trivially true for (0, None). To restrict this further, it must be proven that all inputs that are now excluded produced redundant outputs which are still possible to produce using the reduced input space.

§When to implement try_size_hint

If you 100% know that the type you are implementing Arbitrary for is not a recursive type, or your implementation is not transitively calling any other size_hint methods, you may implement size_hint, and the default try_size_hint implementation will use it.

Note that if you are implementing Arbitrary for a generic type, you cannot guarantee the lack of type recursion!

Otherwise, when there is possible type recursion, you should implement try_size_hint instead.

§The depth parameter

When implementing try_size_hint, you need to use arbitrary::size_hint::try_recursion_guard(depth) to prevent potential infinite recursion when calculating size hints for potentially recursive types:

use arbitrary::{size_hint, Arbitrary, MaxRecursionReached, Unstructured};

// This can potentially be a recursive type if `L` or `R` contain
// something like `Box<Option<MyEither<L, R>>>`!
enum MyEither<L, R> {
    Left(L),
    Right(R),
}

impl<'a, L, R> Arbitrary<'a> for MyEither<L, R>
where
    L: Arbitrary<'a>,
    R: Arbitrary<'a>,
{
    fn arbitrary(u: &mut Unstructured) -> arbitrary::Result<Self> {
        // ...
    }

    fn size_hint(depth: usize) -> (usize, Option<usize>) {
        // Return the value of `try_size_hint`
        //
        // If the recursion fails, return the default `(0, None)` range,
        // which is always valid.
        Self::try_size_hint(depth).unwrap_or_default()
    }

    fn try_size_hint(depth: usize) -> Result<(usize, Option<usize>), MaxRecursionReached> {
        // Protect against potential infinite recursion with
        // `try_recursion_guard`.
        size_hint::try_recursion_guard(depth, |depth| {
            // If we aren't too deep, then `recursion_guard` calls
            // this closure, which implements the natural size hint.
            // Don't forget to use the new `depth` in all nested
            // `try_size_hint` calls! We recommend shadowing the
            // parameter, like what is done here, so that you can't
            // accidentally use the wrong depth.
            Ok(size_hint::or(
                <L as Arbitrary>::try_size_hint(depth)?,
                <R as Arbitrary>::try_size_hint(depth)?,
            ))
        })
    }
}

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types§

§

impl Arbitrary<'_> for OpTxType

Available on crate feature arbitrary only.
§

fn arbitrary(u: &mut Unstructured<'_>) -> Result<OpTxType, Error>

§

impl Arbitrary<'_> for TxType

Available on crate feature arbitrary only.
§

fn arbitrary(u: &mut Unstructured<'_>) -> Result<TxType, Error>

§

impl<'a> Arbitrary<'a> for &'a str

§

impl<'a> Arbitrary<'a> for &'a [u8]

§

fn arbitrary(u: &mut Unstructured<'a>) -> Result<&'a [u8], Error>

§

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<&'a [u8], Error>

§

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

§

impl<'a> Arbitrary<'a> for IpAddr

§

impl<'a> Arbitrary<'a> for SocketAddr

§

impl<'a> Arbitrary<'a> for bool

§

fn arbitrary(u: &mut Unstructured<'a>) -> Result<bool, Error>

§

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

§

impl<'a> Arbitrary<'a> for char

§

fn arbitrary(u: &mut Unstructured<'a>) -> Result<char, Error>

§

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

§

impl<'a> Arbitrary<'a> for f32

§

fn arbitrary(u: &mut Unstructured<'a>) -> Result<f32, Error>

§

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

§

impl<'a> Arbitrary<'a> for f64

§

fn arbitrary(u: &mut Unstructured<'a>) -> Result<f64, Error>

§

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

§

impl<'a> Arbitrary<'a> for i8

§

fn arbitrary(u: &mut Unstructured<'a>) -> Result<i8, Error>

§

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

§

impl<'a> Arbitrary<'a> for i16

§

fn arbitrary(u: &mut Unstructured<'a>) -> Result<i16, Error>

§

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

§

impl<'a> Arbitrary<'a> for i32

§

fn arbitrary(u: &mut Unstructured<'a>) -> Result<i32, Error>

§

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

§

impl<'a> Arbitrary<'a> for i64

§

fn arbitrary(u: &mut Unstructured<'a>) -> Result<i64, Error>

§

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

§

impl<'a> Arbitrary<'a> for i128

§

fn arbitrary(u: &mut Unstructured<'a>) -> Result<i128, Error>

§

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

§

impl<'a> Arbitrary<'a> for isize

§

impl<'a> Arbitrary<'a> for u8

§

fn arbitrary(u: &mut Unstructured<'a>) -> Result<u8, Error>

§

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

§

impl<'a> Arbitrary<'a> for u16

§

fn arbitrary(u: &mut Unstructured<'a>) -> Result<u16, Error>

§

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

§

impl<'a> Arbitrary<'a> for u32

§

fn arbitrary(u: &mut Unstructured<'a>) -> Result<u32, Error>

§

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

§

impl<'a> Arbitrary<'a> for u64

§

fn arbitrary(u: &mut Unstructured<'a>) -> Result<u64, Error>

§

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

§

impl<'a> Arbitrary<'a> for u128

§

fn arbitrary(u: &mut Unstructured<'a>) -> Result<u128, Error>

§

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

§

impl<'a> Arbitrary<'a> for ()

§

fn arbitrary(_: &mut Unstructured<'a>) -> Result<(), Error>

§

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

§

impl<'a> Arbitrary<'a> for usize

§

impl<'a> Arbitrary<'a> for Box<str>

§

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Box<str>, Error>

§

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

§

impl<'a> Arbitrary<'a> for CString

§

impl<'a> Arbitrary<'a> for Rc<str>

§

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Rc<str>, Error>

§

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

§

impl<'a> Arbitrary<'a> for String

§

impl<'a> Arbitrary<'a> for Arc<str>

§

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Arc<str>, Error>

§

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

§

impl<'a> Arbitrary<'a> for PhantomPinned

§

impl<'a> Arbitrary<'a> for Ipv4Addr

§

impl<'a> Arbitrary<'a> for Ipv6Addr

§

impl<'a> Arbitrary<'a> for SocketAddrV4

§

impl<'a> Arbitrary<'a> for SocketAddrV6

§

impl<'a> Arbitrary<'a> for NonZero<i8>

§

impl<'a> Arbitrary<'a> for NonZero<i16>

§

impl<'a> Arbitrary<'a> for NonZero<i32>

§

impl<'a> Arbitrary<'a> for NonZero<i64>

§

impl<'a> Arbitrary<'a> for NonZero<i128>

§

impl<'a> Arbitrary<'a> for NonZero<isize>

§

impl<'a> Arbitrary<'a> for NonZero<u8>

§

impl<'a> Arbitrary<'a> for NonZero<u16>

§

impl<'a> Arbitrary<'a> for NonZero<u32>

§

impl<'a> Arbitrary<'a> for NonZero<u64>

§

impl<'a> Arbitrary<'a> for NonZero<u128>

§

impl<'a> Arbitrary<'a> for NonZero<usize>

§

impl<'a> Arbitrary<'a> for AtomicBool

§

impl<'a> Arbitrary<'a> for AtomicIsize

§

impl<'a> Arbitrary<'a> for AtomicUsize

§

impl<'a> Arbitrary<'a> for Duration

§

impl<'a> Arbitrary<'a> for OsString

§

impl<'a> Arbitrary<'a> for PathBuf

§

impl<'a> Arbitrary<'a> for AddressStorageKey

Available on crate feature arbitrary only.
§

fn arbitrary(u: &mut Unstructured<'a>) -> Result<AddressStorageKey, Error>

§

impl<'a> Arbitrary<'a> for BlockNumberAddress

Available on crate feature arbitrary only.
§

fn arbitrary(u: &mut Unstructured<'a>) -> Result<BlockNumberAddress, Error>

§

impl<'a> Arbitrary<'a> for Capability

Available on crate feature arbitrary only.
§

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Capability, Error>

§

impl<'a> Arbitrary<'a> for IntegerList

Available on crate feature arbitrary only.
§

fn arbitrary(u: &mut Unstructured<'a>) -> Result<IntegerList, Error>

§

impl<'a> Arbitrary<'a> for OpTransactionSigned

Available on crate feature arbitrary only.
§

fn arbitrary(u: &mut Unstructured<'a>) -> Result<OpTransactionSigned, Error>

§

impl<'a> Arbitrary<'a> for TxEip4844

Available on crate feature test-utils only.
§

fn arbitrary(u: &mut Unstructured<'a>) -> Result<TxEip4844, Error>

§

impl<'a, A> Arbitrary<'a> for Cow<'a, A>
where A: ToOwned + 'a + ?Sized, <A as ToOwned>::Owned: Arbitrary<'a>,

§

impl<'a, A> Arbitrary<'a> for Bound<A>
where A: Arbitrary<'a>,

§

impl<'a, A> Arbitrary<'a> for Option<A>
where A: Arbitrary<'a>,

§

impl<'a, A> Arbitrary<'a> for Box<[A]>
where A: Arbitrary<'a>,

§

impl<'a, A> Arbitrary<'a> for Box<A>
where A: Arbitrary<'a>,

§

impl<'a, A> Arbitrary<'a> for BinaryHeap<A>
where A: Arbitrary<'a> + Ord,

§

impl<'a, A> Arbitrary<'a> for BTreeSet<A>
where A: Arbitrary<'a> + Ord,

§

impl<'a, A> Arbitrary<'a> for LinkedList<A>
where A: Arbitrary<'a>,

§

impl<'a, A> Arbitrary<'a> for VecDeque<A>
where A: Arbitrary<'a>,

§

impl<'a, A> Arbitrary<'a> for Rc<[A]>
where A: Arbitrary<'a>,

§

impl<'a, A> Arbitrary<'a> for Rc<A>
where A: Arbitrary<'a>,

§

impl<'a, A> Arbitrary<'a> for Arc<[A]>
where A: Arbitrary<'a>,

§

impl<'a, A> Arbitrary<'a> for Arc<A>
where A: Arbitrary<'a>,

§

impl<'a, A> Arbitrary<'a> for Vec<A>
where A: Arbitrary<'a>,

§

impl<'a, A> Arbitrary<'a> for Cell<A>
where A: Arbitrary<'a>,

§

impl<'a, A> Arbitrary<'a> for RefCell<A>
where A: Arbitrary<'a>,

§

impl<'a, A> Arbitrary<'a> for UnsafeCell<A>
where A: Arbitrary<'a>,

§

impl<'a, A> Arbitrary<'a> for Empty<A>
where A: Arbitrary<'a>,

§

fn arbitrary(_: &mut Unstructured<'a>) -> Result<Empty<A>, Error>

§

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

§

impl<'a, A> Arbitrary<'a> for PhantomData<A>
where A: ?Sized,

§

impl<'a, A> Arbitrary<'a> for Wrapping<A>
where A: Arbitrary<'a>,

§

impl<'a, A> Arbitrary<'a> for Range<A>
where A: Arbitrary<'a> + Clone + PartialOrd,

§

impl<'a, A> Arbitrary<'a> for RangeFrom<A>
where A: Arbitrary<'a> + Clone + PartialOrd,

§

impl<'a, A> Arbitrary<'a> for RangeInclusive<A>
where A: Arbitrary<'a> + Clone + PartialOrd,

§

impl<'a, A> Arbitrary<'a> for RangeTo<A>
where A: Arbitrary<'a> + Clone + PartialOrd,

§

impl<'a, A> Arbitrary<'a> for RangeToInclusive<A>
where A: Arbitrary<'a> + Clone + PartialOrd,

§

impl<'a, A> Arbitrary<'a> for Mutex<A>
where A: Arbitrary<'a>,

§

impl<'a, A> Arbitrary<'a> for SmallVec<A>
where A: Array, <A as Array>::Item: Arbitrary<'a>,

§

fn arbitrary(u: &mut Unstructured<'a>) -> Result<SmallVec<A>, Error>

§

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<SmallVec<A>, Error>

§

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

§

impl<'a, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A> Arbitrary<'a> for (B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A)
where B: Arbitrary<'a>, C: Arbitrary<'a>, D: Arbitrary<'a>, E: Arbitrary<'a>, F: Arbitrary<'a>, G: Arbitrary<'a>, H: Arbitrary<'a>, I: Arbitrary<'a>, J: Arbitrary<'a>, K: Arbitrary<'a>, L: Arbitrary<'a>, M: Arbitrary<'a>, N: Arbitrary<'a>, O: Arbitrary<'a>, P: Arbitrary<'a>, Q: Arbitrary<'a>, R: Arbitrary<'a>, S: Arbitrary<'a>, T: Arbitrary<'a>, U: Arbitrary<'a>, V: Arbitrary<'a>, W: Arbitrary<'a>, X: Arbitrary<'a>, Y: Arbitrary<'a>, Z: Arbitrary<'a>, A: Arbitrary<'a>,

§

impl<'a, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, B> Arbitrary<'a> for (C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, B)
where C: Arbitrary<'a>, D: Arbitrary<'a>, E: Arbitrary<'a>, F: Arbitrary<'a>, G: Arbitrary<'a>, H: Arbitrary<'a>, I: Arbitrary<'a>, J: Arbitrary<'a>, K: Arbitrary<'a>, L: Arbitrary<'a>, M: Arbitrary<'a>, N: Arbitrary<'a>, O: Arbitrary<'a>, P: Arbitrary<'a>, Q: Arbitrary<'a>, R: Arbitrary<'a>, S: Arbitrary<'a>, T: Arbitrary<'a>, U: Arbitrary<'a>, V: Arbitrary<'a>, W: Arbitrary<'a>, X: Arbitrary<'a>, Y: Arbitrary<'a>, Z: Arbitrary<'a>, B: Arbitrary<'a>,

§

impl<'a, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, C> Arbitrary<'a> for (D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, C)
where D: Arbitrary<'a>, E: Arbitrary<'a>, F: Arbitrary<'a>, G: Arbitrary<'a>, H: Arbitrary<'a>, I: Arbitrary<'a>, J: Arbitrary<'a>, K: Arbitrary<'a>, L: Arbitrary<'a>, M: Arbitrary<'a>, N: Arbitrary<'a>, O: Arbitrary<'a>, P: Arbitrary<'a>, Q: Arbitrary<'a>, R: Arbitrary<'a>, S: Arbitrary<'a>, T: Arbitrary<'a>, U: Arbitrary<'a>, V: Arbitrary<'a>, W: Arbitrary<'a>, X: Arbitrary<'a>, Y: Arbitrary<'a>, Z: Arbitrary<'a>, C: Arbitrary<'a>,

§

impl<'a, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, D> Arbitrary<'a> for (E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, D)
where E: Arbitrary<'a>, F: Arbitrary<'a>, G: Arbitrary<'a>, H: Arbitrary<'a>, I: Arbitrary<'a>, J: Arbitrary<'a>, K: Arbitrary<'a>, L: Arbitrary<'a>, M: Arbitrary<'a>, N: Arbitrary<'a>, O: Arbitrary<'a>, P: Arbitrary<'a>, Q: Arbitrary<'a>, R: Arbitrary<'a>, S: Arbitrary<'a>, T: Arbitrary<'a>, U: Arbitrary<'a>, V: Arbitrary<'a>, W: Arbitrary<'a>, X: Arbitrary<'a>, Y: Arbitrary<'a>, Z: Arbitrary<'a>, D: Arbitrary<'a>,

§

impl<'a, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, E> Arbitrary<'a> for (F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, E)
where F: Arbitrary<'a>, G: Arbitrary<'a>, H: Arbitrary<'a>, I: Arbitrary<'a>, J: Arbitrary<'a>, K: Arbitrary<'a>, L: Arbitrary<'a>, M: Arbitrary<'a>, N: Arbitrary<'a>, O: Arbitrary<'a>, P: Arbitrary<'a>, Q: Arbitrary<'a>, R: Arbitrary<'a>, S: Arbitrary<'a>, T: Arbitrary<'a>, U: Arbitrary<'a>, V: Arbitrary<'a>, W: Arbitrary<'a>, X: Arbitrary<'a>, Y: Arbitrary<'a>, Z: Arbitrary<'a>, E: Arbitrary<'a>,

§

impl<'a, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, F> Arbitrary<'a> for (G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, F)
where G: Arbitrary<'a>, H: Arbitrary<'a>, I: Arbitrary<'a>, J: Arbitrary<'a>, K: Arbitrary<'a>, L: Arbitrary<'a>, M: Arbitrary<'a>, N: Arbitrary<'a>, O: Arbitrary<'a>, P: Arbitrary<'a>, Q: Arbitrary<'a>, R: Arbitrary<'a>, S: Arbitrary<'a>, T: Arbitrary<'a>, U: Arbitrary<'a>, V: Arbitrary<'a>, W: Arbitrary<'a>, X: Arbitrary<'a>, Y: Arbitrary<'a>, Z: Arbitrary<'a>, F: Arbitrary<'a>,

§

impl<'a, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, G> Arbitrary<'a> for (H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, G)
where H: Arbitrary<'a>, I: Arbitrary<'a>, J: Arbitrary<'a>, K: Arbitrary<'a>, L: Arbitrary<'a>, M: Arbitrary<'a>, N: Arbitrary<'a>, O: Arbitrary<'a>, P: Arbitrary<'a>, Q: Arbitrary<'a>, R: Arbitrary<'a>, S: Arbitrary<'a>, T: Arbitrary<'a>, U: Arbitrary<'a>, V: Arbitrary<'a>, W: Arbitrary<'a>, X: Arbitrary<'a>, Y: Arbitrary<'a>, Z: Arbitrary<'a>, G: Arbitrary<'a>,

§

impl<'a, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, H> Arbitrary<'a> for (I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, H)
where I: Arbitrary<'a>, J: Arbitrary<'a>, K: Arbitrary<'a>, L: Arbitrary<'a>, M: Arbitrary<'a>, N: Arbitrary<'a>, O: Arbitrary<'a>, P: Arbitrary<'a>, Q: Arbitrary<'a>, R: Arbitrary<'a>, S: Arbitrary<'a>, T: Arbitrary<'a>, U: Arbitrary<'a>, V: Arbitrary<'a>, W: Arbitrary<'a>, X: Arbitrary<'a>, Y: Arbitrary<'a>, Z: Arbitrary<'a>, H: Arbitrary<'a>,

§

impl<'a, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, I> Arbitrary<'a> for (J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, I)
where J: Arbitrary<'a>, K: Arbitrary<'a>, L: Arbitrary<'a>, M: Arbitrary<'a>, N: Arbitrary<'a>, O: Arbitrary<'a>, P: Arbitrary<'a>, Q: Arbitrary<'a>, R: Arbitrary<'a>, S: Arbitrary<'a>, T: Arbitrary<'a>, U: Arbitrary<'a>, V: Arbitrary<'a>, W: Arbitrary<'a>, X: Arbitrary<'a>, Y: Arbitrary<'a>, Z: Arbitrary<'a>, I: Arbitrary<'a>,

§

impl<'a, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, J> Arbitrary<'a> for (K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, J)
where K: Arbitrary<'a>, L: Arbitrary<'a>, M: Arbitrary<'a>, N: Arbitrary<'a>, O: Arbitrary<'a>, P: Arbitrary<'a>, Q: Arbitrary<'a>, R: Arbitrary<'a>, S: Arbitrary<'a>, T: Arbitrary<'a>, U: Arbitrary<'a>, V: Arbitrary<'a>, W: Arbitrary<'a>, X: Arbitrary<'a>, Y: Arbitrary<'a>, Z: Arbitrary<'a>, J: Arbitrary<'a>,

§

impl<'a, K, V> Arbitrary<'a> for BTreeMap<K, V>
where K: Arbitrary<'a> + Ord, V: Arbitrary<'a>,

§

impl<'a, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, K> Arbitrary<'a> for (L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, K)
where L: Arbitrary<'a>, M: Arbitrary<'a>, N: Arbitrary<'a>, O: Arbitrary<'a>, P: Arbitrary<'a>, Q: Arbitrary<'a>, R: Arbitrary<'a>, S: Arbitrary<'a>, T: Arbitrary<'a>, U: Arbitrary<'a>, V: Arbitrary<'a>, W: Arbitrary<'a>, X: Arbitrary<'a>, Y: Arbitrary<'a>, Z: Arbitrary<'a>, K: Arbitrary<'a>,

§

impl<'a, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, L> Arbitrary<'a> for (M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, L)
where M: Arbitrary<'a>, N: Arbitrary<'a>, O: Arbitrary<'a>, P: Arbitrary<'a>, Q: Arbitrary<'a>, R: Arbitrary<'a>, S: Arbitrary<'a>, T: Arbitrary<'a>, U: Arbitrary<'a>, V: Arbitrary<'a>, W: Arbitrary<'a>, X: Arbitrary<'a>, Y: Arbitrary<'a>, Z: Arbitrary<'a>, L: Arbitrary<'a>,

§

impl<'a, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, M> Arbitrary<'a> for (N, O, P, Q, R, S, T, U, V, W, X, Y, Z, M)
where N: Arbitrary<'a>, O: Arbitrary<'a>, P: Arbitrary<'a>, Q: Arbitrary<'a>, R: Arbitrary<'a>, S: Arbitrary<'a>, T: Arbitrary<'a>, U: Arbitrary<'a>, V: Arbitrary<'a>, W: Arbitrary<'a>, X: Arbitrary<'a>, Y: Arbitrary<'a>, Z: Arbitrary<'a>, M: Arbitrary<'a>,

§

impl<'a, O, P, Q, R, S, T, U, V, W, X, Y, Z, N> Arbitrary<'a> for (O, P, Q, R, S, T, U, V, W, X, Y, Z, N)
where O: Arbitrary<'a>, P: Arbitrary<'a>, Q: Arbitrary<'a>, R: Arbitrary<'a>, S: Arbitrary<'a>, T: Arbitrary<'a>, U: Arbitrary<'a>, V: Arbitrary<'a>, W: Arbitrary<'a>, X: Arbitrary<'a>, Y: Arbitrary<'a>, Z: Arbitrary<'a>, N: Arbitrary<'a>,

§

impl<'a, P, Q, R, S, T, U, V, W, X, Y, Z, O> Arbitrary<'a> for (P, Q, R, S, T, U, V, W, X, Y, Z, O)
where P: Arbitrary<'a>, Q: Arbitrary<'a>, R: Arbitrary<'a>, S: Arbitrary<'a>, T: Arbitrary<'a>, U: Arbitrary<'a>, V: Arbitrary<'a>, W: Arbitrary<'a>, X: Arbitrary<'a>, Y: Arbitrary<'a>, Z: Arbitrary<'a>, O: Arbitrary<'a>,

§

impl<'a, Q, R, S, T, U, V, W, X, Y, Z, P> Arbitrary<'a> for (Q, R, S, T, U, V, W, X, Y, Z, P)
where Q: Arbitrary<'a>, R: Arbitrary<'a>, S: Arbitrary<'a>, T: Arbitrary<'a>, U: Arbitrary<'a>, V: Arbitrary<'a>, W: Arbitrary<'a>, X: Arbitrary<'a>, Y: Arbitrary<'a>, Z: Arbitrary<'a>, P: Arbitrary<'a>,

§

impl<'a, R, S, T, U, V, W, X, Y, Z, Q> Arbitrary<'a> for (R, S, T, U, V, W, X, Y, Z, Q)
where R: Arbitrary<'a>, S: Arbitrary<'a>, T: Arbitrary<'a>, U: Arbitrary<'a>, V: Arbitrary<'a>, W: Arbitrary<'a>, X: Arbitrary<'a>, Y: Arbitrary<'a>, Z: Arbitrary<'a>, Q: Arbitrary<'a>,

§

impl<'a, S, T, U, V, W, X, Y, Z, R> Arbitrary<'a> for (S, T, U, V, W, X, Y, Z, R)
where S: Arbitrary<'a>, T: Arbitrary<'a>, U: Arbitrary<'a>, V: Arbitrary<'a>, W: Arbitrary<'a>, X: Arbitrary<'a>, Y: Arbitrary<'a>, Z: Arbitrary<'a>, R: Arbitrary<'a>,

§

impl<'a, T> Arbitrary<'a> for Block<T>
where T: Arbitrary<'a>,

Available on crate feature arbitrary only.
§

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Block<T>, Error>

§

impl<'a, T> Arbitrary<'a> for OpDepositReceipt<T>
where T: Arbitrary<'a>,

Available on crate feature arbitrary only.
§

fn arbitrary(u: &mut Unstructured<'a>) -> Result<OpDepositReceipt<T>, Error>

§

impl<'a, T, E> Arbitrary<'a> for Result<T, E>
where T: Arbitrary<'a>, E: Arbitrary<'a>,

§

impl<'a, T, U, V, W, X, Y, Z, S> Arbitrary<'a> for (T, U, V, W, X, Y, Z, S)
where T: Arbitrary<'a>, U: Arbitrary<'a>, V: Arbitrary<'a>, W: Arbitrary<'a>, X: Arbitrary<'a>, Y: Arbitrary<'a>, Z: Arbitrary<'a>, S: Arbitrary<'a>,

§

impl<'a, T, const N: usize> Arbitrary<'a> for [T; N]
where T: Arbitrary<'a>,

§

impl<'a, U, V, W, X, Y, Z, T> Arbitrary<'a> for (U, V, W, X, Y, Z, T)
where U: Arbitrary<'a>, V: Arbitrary<'a>, W: Arbitrary<'a>, X: Arbitrary<'a>, Y: Arbitrary<'a>, Z: Arbitrary<'a>, T: Arbitrary<'a>,

§

impl<'a, V, W, X, Y, Z, U> Arbitrary<'a> for (V, W, X, Y, Z, U)
where V: Arbitrary<'a>, W: Arbitrary<'a>, X: Arbitrary<'a>, Y: Arbitrary<'a>, Z: Arbitrary<'a>, U: Arbitrary<'a>,

§

impl<'a, W, X, Y, Z, V> Arbitrary<'a> for (W, X, Y, Z, V)
where W: Arbitrary<'a>, X: Arbitrary<'a>, Y: Arbitrary<'a>, Z: Arbitrary<'a>, V: Arbitrary<'a>,

§

impl<'a, X, Y, Z, W> Arbitrary<'a> for (X, Y, Z, W)
where X: Arbitrary<'a>, Y: Arbitrary<'a>, Z: Arbitrary<'a>, W: Arbitrary<'a>,

§

impl<'a, Y, Z, X> Arbitrary<'a> for (Y, Z, X)
where Y: Arbitrary<'a>, Z: Arbitrary<'a>, X: Arbitrary<'a>,

§

impl<'a, Z> Arbitrary<'a> for (Z,)
where Z: Arbitrary<'a>,

§

impl<'a, Z, Y> Arbitrary<'a> for (Z, Y)
where Z: Arbitrary<'a>, Y: Arbitrary<'a>,

§

impl<'arbitrary> Arbitrary<'arbitrary> for AccountBeforeTx

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<AccountBeforeTx, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<AccountBeforeTx, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for AccountHashingCheckpoint

§

fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<AccountHashingCheckpoint, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<AccountHashingCheckpoint, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for Authorization

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Authorization, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<Authorization, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for BlockHashNumber

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<BlockHashNumber, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<BlockHashNumber, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for BlockWithParent

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<BlockWithParent, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<BlockWithParent, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for CheckpointBlockRange

§

fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<CheckpointBlockRange, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<CheckpointBlockRange, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for ClientVersion

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<ClientVersion, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<ClientVersion, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for CompactClientVersion

§

fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<CompactClientVersion, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<CompactClientVersion, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for CompactU64

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<CompactU64, Error>

§

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<CompactU64, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for CompactU256

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<CompactU256, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<CompactU256, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for ConsolidationRequest

§

fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<ConsolidationRequest, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<ConsolidationRequest, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for DepositRequest

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<DepositRequest, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<DepositRequest, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for Eip658Value

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Eip658Value, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<Eip658Value, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for EntitiesCheckpoint

§

fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<EntitiesCheckpoint, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<EntitiesCheckpoint, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for EthVersion

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<EthVersion, Error>

§

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<EthVersion, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for ExecutionCheckpoint

§

fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<ExecutionCheckpoint, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<ExecutionCheckpoint, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for GenesisAccount

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<GenesisAccount, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<GenesisAccount, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for GetBlockBodies

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<GetBlockBodies, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<GetBlockBodies, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for GetBlockHeaders

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<GetBlockHeaders, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<GetBlockHeaders, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for GetNodeData

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<GetNodeData, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<GetNodeData, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for GetPooledTransactions

§

fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<GetPooledTransactions, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<GetPooledTransactions, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for GetReceipts

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<GetReceipts, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<GetReceipts, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for HashBuilderState

§

fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<HashBuilderState, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<HashBuilderState, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for HashOrNumber

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<HashOrNumber, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<HashOrNumber, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for Header

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Header, Error>

§

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Header, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for HeaderExt

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<HeaderExt, Error>

§

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<HeaderExt, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for HeadersCheckpoint

§

fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<HeadersCheckpoint, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<HeadersCheckpoint, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for HeadersDirection

§

fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<HeadersDirection, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<HeadersDirection, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for HelloMessage

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<HelloMessage, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<HelloMessage, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for IndexHistoryCheckpoint

§

fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<IndexHistoryCheckpoint, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<IndexHistoryCheckpoint, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for NewBlockHashes

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<NewBlockHashes, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<NewBlockHashes, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for NewPooledTransactionHashes66

§

fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<NewPooledTransactionHashes66, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<NewPooledTransactionHashes66, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for Nibbles

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Nibbles, Error>

§

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Nibbles, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for NodeData

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<NodeData, Error>

§

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<NodeData, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for NumHash

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<NumHash, Error>

§

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<NumHash, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for OpReceipt

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<OpReceipt, Error>

§

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<OpReceipt, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for OpTypedTransaction

§

fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<OpTypedTransaction, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<OpTypedTransaction, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for P2PMessage

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<P2PMessage, Error>

§

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<P2PMessage, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for ProtocolVersion

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<ProtocolVersion, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<ProtocolVersion, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for PruneCheckpoint

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<PruneCheckpoint, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<PruneCheckpoint, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for PruneMode

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<PruneMode, Error>

§

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<PruneMode, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for Requests

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Requests, Error>

§

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Requests, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for StageCheckpoint

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<StageCheckpoint, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<StageCheckpoint, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for StageUnitCheckpoint

§

fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<StageUnitCheckpoint, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<StageUnitCheckpoint, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for Status

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Status, Error>

§

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Status, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for StorageHashingCheckpoint

§

fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<StorageHashingCheckpoint, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<StorageHashingCheckpoint, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for StoredBlockBodyIndices

§

fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<StoredBlockBodyIndices, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<StoredBlockBodyIndices, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for StoredBlockWithdrawals

§

fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<StoredBlockWithdrawals, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<StoredBlockWithdrawals, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for StoredNibbles

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<StoredNibbles, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<StoredNibbles, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for StoredNibblesSubKey

§

fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<StoredNibblesSubKey, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<StoredNibblesSubKey, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for TrieMask

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<TrieMask, Error>

§

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<TrieMask, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for TxDeposit

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<TxDeposit, Error>

§

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<TxDeposit, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for TxDeposit

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<TxDeposit, Error>

§

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<TxDeposit, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for TxEip1559

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<TxEip1559, Error>

§

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<TxEip1559, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for TxEip1559

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<TxEip1559, Error>

§

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<TxEip1559, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for TxEip2930

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<TxEip2930, Error>

§

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<TxEip2930, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for TxEip2930

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<TxEip2930, Error>

§

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<TxEip2930, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for TxEip4844

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<TxEip4844, Error>

§

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<TxEip4844, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for TxEip7702

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<TxEip7702, Error>

§

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<TxEip7702, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for TxEip7702

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<TxEip7702, Error>

§

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<TxEip7702, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for TxEip4844Variant

§

fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<TxEip4844Variant, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<TxEip4844Variant, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for TxEip4844WithSidecar

§

fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<TxEip4844WithSidecar, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<TxEip4844WithSidecar, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for TxLegacy

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<TxLegacy, Error>

§

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<TxLegacy, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for TxLegacy

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<TxLegacy, Error>

§

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<TxLegacy, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for Withdrawal

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Withdrawal, Error>

§

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Withdrawal, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary> Arbitrary<'arbitrary> for WithdrawalRequest

§

fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<WithdrawalRequest, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<WithdrawalRequest, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary, B> Arbitrary<'arbitrary> for BlockBodies<B>
where B: Arbitrary<'arbitrary>,

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<BlockBodies<B>, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<BlockBodies<B>, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary, B> Arbitrary<'arbitrary> for NewBlock<B>
where B: Arbitrary<'arbitrary>,

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<NewBlock<B>, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<NewBlock<B>, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary, H> Arbitrary<'arbitrary> for BlockHeaders<H>
where H: Arbitrary<'arbitrary>,

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<BlockHeaders<H>, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<BlockHeaders<H>, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary, H> Arbitrary<'arbitrary> for StoredBlockOmmers<H>
where H: Arbitrary<'arbitrary>,

§

fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<StoredBlockOmmers<H>, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<StoredBlockOmmers<H>, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary, T> Arbitrary<'arbitrary> for Receipts<T>
where T: Arbitrary<'arbitrary>,

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Receipts<T>, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<Receipts<T>, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary, T> Arbitrary<'arbitrary> for SharedTransactions<T>
where T: Arbitrary<'arbitrary>,

§

fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<SharedTransactions<T>, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<SharedTransactions<T>, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'arbitrary, T> Arbitrary<'arbitrary> for Transactions<T>
where T: Arbitrary<'arbitrary>,

§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Transactions<T>, Error>

§

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<Transactions<T>, Error>

§

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

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

§

impl<'u> Arbitrary<'u> for HashBuilderValue

Available on crate feature arbitrary only.
§

fn arbitrary(g: &mut Unstructured<'u>) -> Result<HashBuilderValue, Error>

§

impl<'u> Arbitrary<'u> for RlpNode

Available on crate feature arbitrary only.
§

fn arbitrary(g: &mut Unstructured<'u>) -> Result<RlpNode, Error>

Implementors§

§

impl Arbitrary<'_> for OtherFields

§

impl<'a> Arbitrary<'a> for Transaction

Available on crate feature arbitrary only.
§

impl<'a> Arbitrary<'a> for Chain

Available on crate feature arbitrary only.
§

impl<'a> Arbitrary<'a> for Bloom

§

impl<'a> Arbitrary<'a> for Function

§

impl<'a> Arbitrary<'a> for PrimitiveSignature

Available on crate feature arbitrary only.
§

impl<'a> Arbitrary<'a> for Signature

Available on crate feature arbitrary only.
§

impl<'a> Arbitrary<'a> for SignedAuthorization

Available on crate features arbitrary and k256 only.
§

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

§

impl<'a> Arbitrary<'a> for Bytes

Available on crate feature arbitrary only.
§

impl<'a> Arbitrary<'a> for BlobTransactionSidecar

Available on crate feature arbitrary only.
§

impl<'a> Arbitrary<'a> for reth::primitives::Block

Available on crate feature arbitrary only.
§

impl<'a> Arbitrary<'a> for BlockBody

Available on crate feature arbitrary only.
§

impl<'a> Arbitrary<'a> for reth::primitives::Header

Available on crate feature arbitrary only.
§

impl<'a> Arbitrary<'a> for reth::primitives::Receipt

Available on crate feature arbitrary only.
§

impl<'a> Arbitrary<'a> for SealedBlockWithSenders

Available on crate feature arbitrary only.
§

impl<'a> Arbitrary<'a> for TransactionSigned

Available on crate feature arbitrary only.
§

impl<'a, A, S> Arbitrary<'a> for HashSet<A, S>
where A: Arbitrary<'a> + Eq + Hash, S: BuildHasher + Default,

§

impl<'a, H> Arbitrary<'a> for SealedHeader<H>
where H: for<'b> Arbitrary<'b> + Sealable,

Available on crate feature arbitrary only.
§

impl<'a, H, B> Arbitrary<'a> for SealedBlock<H, B>
where SealedHeader<H>: Arbitrary<'a>, B: Arbitrary<'a>,

Available on crate feature arbitrary only.
§

impl<'a, K, V, S> Arbitrary<'a> for HashMap<K, V, S>
where K: Arbitrary<'a> + Eq + Hash, V: Arbitrary<'a>, S: BuildHasher + Default,

§

impl<'a, R> Arbitrary<'a> for ReceiptWithBloom<R>
where R: Arbitrary<'a>,

Available on crate feature arbitrary only.
§

impl<'a, T> Arbitrary<'a> for ReceiptEnvelope<T>
where T: Arbitrary<'a>,

Available on crate feature arbitrary only.
§

impl<'a, T> Arbitrary<'a> for Sealed<T>
where T: for<'b> Arbitrary<'b> + Sealable,

Available on crate feature arbitrary only.
§

impl<'a, const BITS: usize, const LIMBS: usize> Arbitrary<'a> for Uint<BITS, LIMBS>

§

impl<'arbitrary> Arbitrary<'arbitrary> for DisconnectReason

§

impl<'arbitrary> Arbitrary<'arbitrary> for Parity

§

impl<'arbitrary> Arbitrary<'arbitrary> for TxKind

§

impl<'arbitrary> Arbitrary<'arbitrary> for reth::primitives::TxType

§

impl<'arbitrary> Arbitrary<'arbitrary> for BaseFeeParams

§

impl<'arbitrary> Arbitrary<'arbitrary> for LogData

§

impl<'arbitrary> Arbitrary<'arbitrary> for AccessList

§

impl<'arbitrary> Arbitrary<'arbitrary> for AccessListItem

§

impl<'arbitrary> Arbitrary<'arbitrary> for TrieAccount

§

impl<'arbitrary> Arbitrary<'arbitrary> for reth::rpc::types::Authorization

§

impl<'arbitrary> Arbitrary<'arbitrary> for TransactionInput

§

impl<'arbitrary> Arbitrary<'arbitrary> for TransactionRequest

§

impl<'arbitrary> Arbitrary<'arbitrary> for reth::rpc::types::Withdrawal

§

impl<'arbitrary> Arbitrary<'arbitrary> for Withdrawals

§

impl<'arbitrary> Arbitrary<'arbitrary> for Account

§

impl<'arbitrary> Arbitrary<'arbitrary> for ForkHash

§

impl<'arbitrary> Arbitrary<'arbitrary> for ForkId

§

impl<'arbitrary> Arbitrary<'arbitrary> for StorageEntry

§

impl<'arbitrary, H> Arbitrary<'arbitrary> for reth::rpc::types::Header<H>
where H: Arbitrary<'arbitrary>,

§

impl<'arbitrary, T> Arbitrary<'arbitrary> for reth::revm::revm::precompile::Log<T>
where T: Arbitrary<'arbitrary>,

§

impl<'arbitrary, T> Arbitrary<'arbitrary> for WithOtherFields<T>
where T: Arbitrary<'arbitrary>,

§

impl<'arbitrary, T> Arbitrary<'arbitrary> for reth::rpc::types::Log<T>
where T: Arbitrary<'arbitrary>,

§

impl<'arbitrary, T> Arbitrary<'arbitrary> for reth::rpc::types::Receipt<T>
where T: Arbitrary<'arbitrary>,

§

impl<'arbitrary, T> Arbitrary<'arbitrary> for TransactionReceipt<T>
where T: Arbitrary<'arbitrary>,

§

impl<'arbitrary, const BITS: usize, const LIMBS: usize> Arbitrary<'arbitrary> for Signed<BITS, LIMBS>

§

impl<'arbitrary, const N: usize> Arbitrary<'arbitrary> for FixedBytes<N>