Struct StoredNibblesSubKey

pub struct StoredNibblesSubKey(pub Nibbles);

Expand description

The representation of nibbles of the merkle trie stored in the database.

Tuple Fields§

§0: Nibbles

Implementations§

§

impl StoredNibblesSubKey

pub fn to_compact_array(&self) -> [u8; 65]

Encodes the nibbles into a fixed-size [u8; 65] array.

The first 64 bytes contain the nibble values (right-padded with zeros), and the 65th byte stores the actual nibble count.

Methods from Deref<Target = Nibbles>§

pub fn pack(&self) -> SmallVec<[u8; 32]>

Packs the nibbles into the given slice.

This method combines each pair of consecutive nibbles into a single byte, effectively reducing the size of the data by a factor of two.

If the number of nibbles is odd, the last nibble is shifted left by 4 bits and added to the packed byte vector.

§Examples

let nibbles = Nibbles::from_nibbles(&[0x0A, 0x0B, 0x0C]);
assert_eq!(nibbles.pack()[..], [0xAB, 0xC0]);

pub fn pack_to(&self, out: &mut [u8])

Packs the nibbles into the given slice.

See pack for more information.

§Panics

Panics if the slice is not at least (self.len() + 1) / 2 bytes long.

§Examples

let nibbles = Nibbles::from_nibbles(&[0x0A, 0x0B, 0x0C]);
let mut packed = [0; 2];
nibbles.pack_to(&mut packed);
assert_eq!(packed[..], [0xAB, 0xC0]);

pub unsafe fn pack_to_unchecked(&self, ptr: *mut u8)

Packs the nibbles into the given pointer.

See pack for more information.

§Safety

ptr must be valid for at least (self.len() + 1) / 2 bytes.

§Examples

let nibbles = Nibbles::from_nibbles(&[0x0A, 0x0B, 0x0C, 0x0D]);
let mut packed = [0; 2];
// SAFETY: enough capacity.
unsafe { nibbles.pack_to_unchecked(packed.as_mut_ptr()) };
assert_eq!(packed[..], [0xAB, 0xCD]);

pub unsafe fn pack_to_slice_unchecked(&self, out: &mut [MaybeUninit<u8>])

Packs the nibbles into the given slice without checking its length.

See pack for more information.

§Safety

out must be valid for at least (self.len() + 1) / 2 bytes.

pub fn to_vec(&self) -> Vec<u8> ⓘ

Converts the nibbles into a vector of nibbles.

§Examples

let nibbles = Nibbles::from_nibbles(&[0x0A, 0x0B, 0x0C, 0x0D]);
assert_eq!(nibbles.to_vec(), vec![0x0A, 0x0B, 0x0C, 0x0D]);

pub fn iter(&self) -> NibblesIter<'_> ⓘ

Returns an iterator over the nibbles.

§Examples

let nibbles = Nibbles::from_nibbles(&[0x0A, 0x0B, 0x0C, 0x0D]);
let collected: Vec<u8> = nibbles.iter().collect();
assert_eq!(collected, vec![0x0A, 0x0B, 0x0C, 0x0D]);

pub fn get_byte(&self, i: usize) -> Option<u8>

Gets the byte at the given index by combining two consecutive nibbles.

§Examples

let nibbles = Nibbles::from_nibbles(&[0x0A, 0x0B, 0x0C, 0x0D]);
assert_eq!(nibbles.get_byte(0), Some(0xAB));
assert_eq!(nibbles.get_byte(1), Some(0xBC));
assert_eq!(nibbles.get_byte(2), Some(0xCD));
assert_eq!(nibbles.get_byte(3), None);

pub fn get_byte_unchecked(&self, i: usize) -> u8

Gets the byte at the given index by combining two consecutive nibbles.

§Panics

Panics if i..i + 1 is out of bounds.

§Examples

let nibbles = Nibbles::from_nibbles(&[0x0A, 0x0B, 0x0C, 0x0D]);
// SAFETY: in range.
unsafe {
    assert_eq!(nibbles.get_byte_unchecked(0), 0xAB);
    assert_eq!(nibbles.get_byte_unchecked(1), 0xBC);
    assert_eq!(nibbles.get_byte_unchecked(2), 0xCD);
}

pub fn increment(&self) -> Option<Nibbles>

Increments the nibble sequence by one.

pub fn is_leaf(&self) -> bool

The last element of the hex vector is used to determine whether the nibble sequence represents a leaf or an extension node. If the last element is 0x10 (16), then it’s a leaf.

pub fn starts_with(&self, other: &Nibbles) -> bool

Returns true if this nibble sequence starts with the given prefix.

pub fn ends_with(&self, other: &Nibbles) -> bool

Returns true if this nibble sequence ends with the given suffix.

pub fn get(&self, i: usize) -> Option<u8>

Returns the nibble at the given index.

pub fn get_unchecked(&self, i: usize) -> u8

Returns the nibble at the given index.

§Panics

Panics if the index is out of bounds.

pub fn first(&self) -> Option<u8>

Returns the first nibble of this nibble sequence.

pub fn last(&self) -> Option<u8>

Returns the last nibble of this nibble sequence.

pub fn common_prefix_length(&self, other: &Nibbles) -> usize

Returns the length of the common prefix between this nibble sequence and the given.

§Examples

let a = Nibbles::from_nibbles(&[0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F]);
let b = Nibbles::from_nibbles(&[0x0A, 0x0B, 0x0C, 0x0E]);
assert_eq!(a.common_prefix_length(&b), 3);

pub fn is_empty(&self) -> bool

Returns true if this Nibbles is empty.

pub fn is_zeroes(&self) -> bool

Returns true if all nibbles in this Nibbles are zero.

pub fn len(&self) -> usize

Returns the total number of nibbles in this Nibbles.

pub fn byte_len(&self) -> usize

Returns the total number of bytes in this Nibbles.

pub fn next_without_prefix(&self) -> Option<Nibbles>

Returns the next nibble sequence in lexicographical order that is not a prefix of self.

Returns None if the nibbles are empty or if no such value exists (all nibbles are 0xF).

§Examples

use nybbles::Nibbles;

let nibbles = Nibbles::from_nibbles([0x1, 0x2, 0x3]);
assert_eq!(nibbles.next_without_prefix(), Some(Nibbles::from_nibbles([0x1, 0x2, 0x4])));

let nibbles = Nibbles::from_nibbles([0x0, 0x0, 0xF]);
assert_eq!(nibbles.next_without_prefix(), Some(Nibbles::from_nibbles([0x0, 0x1])));

let nibbles = Nibbles::from_nibbles([0xF, 0xF, 0xF]);
assert_eq!(nibbles.next_without_prefix(), None);

pub fn slice_unchecked(&self, start: usize, end: usize) -> Nibbles

Creates new nibbles containing the nibbles in the specified range [start, end) without checking bounds.

§Safety

This method does not verify that the provided range is valid for this nibble sequence. The caller must ensure that start <= end and end <= self.len().