Struct hotshot_stake_table::mt_based::StakeTable

pub struct StakeTable<K: Key> {
    head: Arc<PersistentMerkleNode<K>>,
    epoch_start: Arc<PersistentMerkleNode<K>>,
    last_epoch_start: Arc<PersistentMerkleNode<K>>,
    height: usize,
    mapping: HashMap<K, usize>,
}

Locally maintained stake table, generic over public key type K.

Fields

head: Arc<PersistentMerkleNode<K>>

The most up-to-date stake table, where the incoming transactions shall be performed on.

epoch_start: Arc<PersistentMerkleNode<K>>

The snapshot of stake table at the beginning of the current epoch

last_epoch_start: Arc<PersistentMerkleNode<K>>

The stake table used for leader election.

height: usize

Height of the underlying merkle tree, determines the capacity. The capacity is TREE_BRANCH.pow(height).

mapping: HashMap<K, usize>

The mapping from public keys to their location in the Merkle tree.

Implementations

impl<K: Key> StakeTable<K>

pub fn new(height: usize) -> Self

Initiating an empty stake table. Overall capacity is TREE_BRANCH.pow(height).

fn root( &self, version: &SnapshotVersion, ) -> Result<Arc<PersistentMerkleNode<K>>, StakeTableError>

returns the root of stake table at version

pub fn advance(&mut self)

Update the stake table when the epoch number advances, should be manually called.

pub fn set_value( &mut self, key: &K, value: U256, ) -> Result<U256, StakeTableError>

Set the stake withheld by key to be value. Return the previous stake if succeed.

Errors

Errors if the key is not found in the staketable

Trait Implementations

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

fn clone(&self) -> StakeTable<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 StakeTable<K>

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

Formats the value using the given formatter.

impl<'de, K> Deserialize<'de> for StakeTable<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: PartialEq + Key> PartialEq for StakeTable<K>

fn eq(&self, other: &StakeTable<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 StakeTable<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: Key> StakeTableScheme for StakeTable<K>

fn sample( &self, rng: &mut (impl SeedableRng + CryptoRngCore), ) -> Option<(&Self::Key, &Self::Amount)>

Almost uniformly samples a key weighted by its stake from the last_epoch_start stake table

type Key = K

type for stake key

type Amount = U256

type for the staked amount

type Commitment = MerkleCommitment

type for the commitment to the current stake table

type LookupProof = MerkleProof<K>

type for the proof associated with the lookup result (if any)

type IntoIter = IntoIter<K>

type for the iterator over (key, value) entries

type Aux = ()

Auxiliary information associated with the key

fn register( &mut self, new_key: Self::Key, amount: Self::Amount, (): Self::Aux, ) -> Result<(), StakeTableError>

Register a new key into the stake table.

fn deregister( &mut self, _existing_key: &Self::Key, ) -> Result<(), StakeTableError>

Deregister an existing key from the stake table. Returns error if some keys are not found.

fn commitment( &self, version: SnapshotVersion, ) -> Result<Self::Commitment, StakeTableError>

Returns the commitment to the version of stake table.

fn total_stake( &self, version: SnapshotVersion, ) -> Result<Self::Amount, StakeTableError>

Returns the accumulated stakes of all registered keys of the version of stake table.

fn len(&self, version: SnapshotVersion) -> Result<usize, StakeTableError>

Returns the number of keys in the version of the table.

fn contains_key(&self, key: &Self::Key) -> bool

Returns true if key is currently registered, else returns false.

fn lookup( &self, version: SnapshotVersion, key: &K, ) -> Result<Self::Amount, StakeTableError>

Returns the stakes withhelded by a public key.

fn lookup_with_proof( &self, version: SnapshotVersion, key: &Self::Key, ) -> Result<(Self::Amount, Self::LookupProof), StakeTableError>

Returns the stakes withhelded by a public key along with a membership proof.

fn lookup_with_aux_and_proof( &self, version: SnapshotVersion, key: &Self::Key, ) -> Result<(Self::Amount, Self::Aux, Self::LookupProof), StakeTableError>

Return the associated stake amount and auxiliary information of a public key, along with a membership proof.

fn update( &mut self, key: &Self::Key, delta: Self::Amount, negative: bool, ) -> Result<Self::Amount, StakeTableError>

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

fn try_iter( &self, version: SnapshotVersion, ) -> Result<Self::IntoIter, StakeTableError>

Returns an iterator over all (key, value) entries of the version of the table

fn batch_register<I, J, K>( &mut self, new_keys: I, amounts: J, auxs: K, ) -> Result<(), StakeTableError>

where I: IntoIterator<Item = Self::Key>, J: IntoIterator<Item = Self::Amount>, K: IntoIterator<Item = Self::Aux>,

Batch register a list of new keys. A default implementation is provided w/o batch optimization.

fn batch_deregister<'a, I>( &mut self, existing_keys: I, ) -> Result<(), StakeTableError>

where I: IntoIterator<Item = &'a Self::Key>, Self::Key: 'a,

Batch deregister a list of keys. A default implementation is provided w/o batch optimization.

fn batch_update( &mut self, keys: &[Self::Key], amounts: &[Self::Amount], negative_flags: Vec<bool>, ) -> Result<Vec<Self::Amount>, StakeTableError>

Batch update the stake balance of keys. Read documentation about [Self::update()]. By default, we call Self::update() on each (key, amount, negative) tuple.

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

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