Struct KeccakNode 

pub struct KeccakNode(pub [u8; 32]);

Custom Keccak256 node for our merkle tree

Tuple Fields

0: [u8; 32]

Trait Implementations

impl AsRef<[u8]> for KeccakNode

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

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

impl CanonicalDeserialize for KeccakNode

fn deserialize_with_mode<R: Read>( reader: R, _compress: Compress, _validate: Validate, ) -> Result<Self, SerializationError>

The general deserialize method that takes in customization flags.

fn deserialize_compressed<R>(reader: R) -> Result<Self, SerializationError>

where R: Read,

fn deserialize_compressed_unchecked<R>( reader: R, ) -> Result<Self, SerializationError>

where R: Read,

fn deserialize_uncompressed<R>(reader: R) -> Result<Self, SerializationError>

where R: Read,

fn deserialize_uncompressed_unchecked<R>( reader: R, ) -> Result<Self, SerializationError>

where R: Read,

impl CanonicalSerialize for KeccakNode

fn serialize_with_mode<W: Write>( &self, writer: W, _compress: Compress, ) -> Result<(), SerializationError>

The general serialize method that takes in customization flags.

fn serialized_size(&self, _compress: Compress) -> usize

fn serialize_compressed<W>(&self, writer: W) -> Result<(), SerializationError>

where W: Write,

fn compressed_size(&self) -> usize

fn serialize_uncompressed<W>(&self, writer: W) -> Result<(), SerializationError>

where W: Write,

fn uncompressed_size(&self) -> usize

impl Clone for KeccakNode

fn clone(&self) -> KeccakNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KeccakNode

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

Formats the value using the given formatter.

impl Default for KeccakNode

fn default() -> KeccakNode

Returns the “default value” for a type.

impl DigestAlgorithm<KeccakNode, OuterIndex, KeccakNode> for OuterKeccak256Hasher

fn digest(data: &[KeccakNode]) -> Result<KeccakNode, MerkleTreeError>

Hash internal nodes by concatenating children and applying Keccak256.

Implements keccak256(child[0] || child[1] || ... || child[n]) matching Solidity’s keccak256(abi.encodePacked(...)).

Arguments

• data - Slice of child node hashes to combine

Returns

The Keccak256 hash of the concatenated children

fn digest_leaf( _pos: &OuterIndex, elem: &KeccakNode, ) -> Result<KeccakNode, MerkleTreeError>

Pass-through for leaf nodes (inner tree roots are already hashed).

Unlike typical Merkle trees where leaves are hashed, the outer tree’s “leaves” are inner tree roots that are already Keccak256 hashes. Hashing them again would add an unnecessary layer and break Solidity verification compatibility.

Arguments

• _pos - Outer index (0-15), unused
• elem - Inner tree root hash (already a Keccak256 digest)

Returns

The input hash unchanged

impl DigestAlgorithm<RewardAmount, RewardAccountV2, KeccakNode> for Keccak256Hasher

fn digest(data: &[KeccakNode]) -> Result<KeccakNode, MerkleTreeError>

Digest a list of values

fn digest_leaf( _pos: &RewardAccountV2, elem: &RewardAmount, ) -> Result<KeccakNode, MerkleTreeError>

Digest an indexed element

impl From<KeccakNode> for B256

fn from(val: KeccakNode) -> Self

Converts to this type from the input type.

impl Hash for KeccakNode

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 Ord for KeccakNode

fn cmp(&self, other: &KeccakNode) -> 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 for KeccakNode

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

fn partial_cmp(&self, other: &KeccakNode) -> 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 Valid for KeccakNode

fn check(&self) -> Result<(), SerializationError>

fn batch_check<'a>( batch: impl Iterator<Item = &'a Self> + Send, ) -> Result<(), SerializationError>

where Self: 'a,

impl Copy for KeccakNode

impl Eq for KeccakNode

impl StructuralPartialEq for KeccakNode