Struct OuterIndex 

pub struct OuterIndex(pub u8);

Outer tree index (0-15) derived from account address high nibble.

Represents the partition index in the outer tree, calculated as the first 4 bits (high nibble) of an account address:

Address:     0xABCDEF...
               ^
             High nibble = A (hex) = 10 (decimal)
OuterIndex:  10

This partitions the 160-bit address space into 16 equal-sized buckets (2^156 addresses each), allowing efficient storage and lookup.

Tuple Fields

0: u8

Implementations

impl OuterIndex

pub const MAX: u8 = 15

Maximum valid outer index (2^4 - 1 = 15).

pub fn new(account: &RewardAccountV2) -> Self

Extract outer index from a reward account address.

Takes the high nibble (first 4 bits) of the account address’s first byte. Since Ethereum addresses are big-endian, this is byte[0] >> 4.

Example

Account: 0xA1B2C3D4E5F6...
Byte[0]: 0xA1 = 0b1010_0001
>> 4:    0x0A = 0b0000_1010 = 10
Result:  OuterIndex(10)

Arguments

• account - The reward account (Ethereum address)

Returns

An OuterIndex in the range [0, 15]

pub fn value(&self) -> u8

Get the raw index value (0-15).

Returns

The partition index as a u8

Trait Implementations

impl CanonicalDeserialize for OuterIndex

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 OuterIndex

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 OuterIndex

fn clone(&self) -> OuterIndex

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OuterIndex

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for OuterIndex

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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 Hash for OuterIndex

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 OuterIndex

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

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

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<const ARITY: usize> ToTraversalPath<ARITY> for OuterIndex

fn to_traversal_path(&self, height: usize) -> Vec<usize>

Convert the given index to a vector of branch indices given tree height and ARITY.

impl Valid for OuterIndex

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

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

where Self: 'a,

impl Copy for OuterIndex

impl Eq for OuterIndex

impl StructuralPartialEq for OuterIndex