Enum hotshot_stake_table::mt_based::internal::PersistentMerkleNode

pub(crate) enum PersistentMerkleNode<K: Key> {
    Empty,
    Branch {
        comm: Fq,
        children: [Arc<PersistentMerkleNode<K>>; 3],
        num_keys: usize,
        total_stakes: U256,
    },
    Leaf {
        comm: Fq,
        key: K,
        value: U256,
    },
}

A persistent merkle tree tailored for the stake table. Generic over the key type K

Variants

Empty

Empty

Branch

A branch

Fields

comm: Fq

field type

children: [Arc<PersistentMerkleNode<K>>; 3]

children

num_keys: usize

number of keys

total_stakes: U256

total stake

Leaf

A leaf

Fields

comm: Fq

field type

key: K

the key

value: U256

the value

Implementations

impl<K: Key> PersistentMerkleNode<K>

pub fn commitment(&self) -> Fq

Returns the succinct commitment of this subtree

pub fn num_keys(&self) -> usize

Returns the total number of keys in this subtree

pub fn total_stakes(&self) -> U256

Returns the total stakes in this subtree

pub fn simple_lookup( &self, height: usize, path: &[usize], ) -> Result<U256, StakeTableError>

Returns the stakes withhelded by a public key, None if the key is not registered.

pub fn lookup( &self, height: usize, path: &[usize], ) -> Result<MerkleProof<K>, StakeTableError>

Returns a Merkle proof to the given location

pub fn key_by_stake(&self, stake_number: U256) -> Option<(&K, &U256)>

Imagine that the keys in this subtree is sorted, returns the first key such that the prefix sum of withholding stakes is greater or equal the given stake_number. Useful for key sampling weighted by withholding stakes

pub fn register( &self, height: usize, path: &[usize], key: &K, value: U256, ) -> Result<Arc<Self>, StakeTableError>

Insert a new key into the Merkle tree

pub fn update( &self, height: usize, path: &[usize], key: &K, delta: U256, negative: bool, ) -> Result<(Arc<Self>, U256), StakeTableError>

Update the stake of the key with (negative ? -1 : 1) * delta. Return the updated stake

pub fn set_value( &self, height: usize, path: &[usize], key: &K, value: U256, ) -> Result<(Arc<Self>, U256), StakeTableError>

Set the stake of key to be value. Return the previous stake

Trait Implementations

impl<K: Clone + Key> Clone for PersistentMerkleNode<K>

fn clone(&self) -> PersistentMerkleNode<K>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K: Debug + Key> Debug for PersistentMerkleNode<K>

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

Formats the value using the given formatter.

impl<'de, K> Deserialize<'de> for PersistentMerkleNode<K>

where K: Key,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<K: Hash + Key> Hash for PersistentMerkleNode<K>

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<K: Key> IntoIterator for PersistentMerkleNode<K>

type Item = (K, U256, ())

The type of the elements being iterated over.

type IntoIter = IntoIter<K>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K: PartialEq + Key> PartialEq for PersistentMerkleNode<K>

fn eq(&self, other: &PersistentMerkleNode<K>) -> 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<K> Serialize for PersistentMerkleNode<K>

where K: Key,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<K: Eq + Key> Eq for PersistentMerkleNode<K>

impl<K: Key> StructuralPartialEq for PersistentMerkleNode<K>