Struct solana_entry::entry::Entry

pub struct Entry {
    pub num_hashes: u64,
    pub hash: Hash,
    pub transactions: Vec<VersionedTransaction>,
}

Each Entry contains three pieces of data. The num_hashes field is the number of hashes performed since the previous entry. The hash field is the result of hashing hash from the previous entry num_hashes times. The transactions field points to Transactions that took place shortly before hash was generated.

If you multiply num_hashes by the amount of time it takes to generate a new hash, you get a duration estimate since the last Entry. Since processing power increases over time, one should expect the duration num_hashes represents to decrease proportionally. An upper bound on Duration can be estimated by assuming each hash was generated by the world’s fastest processor at the time the entry was recorded. Or said another way, it is physically not possible for a shorter duration to have occurred if one assumes the hash was computed by the world’s fastest processor at that time. The hash chain is both a Verifiable Delay Function (VDF) and a Proof of Work (not to be confused with Proof of Work consensus!)

The solana core protocol currently requires an Entry to contain transactions that are executable in parallel. Implemented in:

• For TPU: solana_core::banking_stage::BankingStage::process_and_record_transactions()
• For TVU: solana_core::replay_stage::ReplayStage::replay_blockstore_into_bank()

All transactions in the transactions field have to follow the read/write locking restrictions with regard to the accounts they reference. A single account can be either written by a single transaction, or read by one or more transactions, but not both.

This enforcement is done via a call to solana_runtime::accounts::Accounts::lock_accounts() with the txs argument holding all the transactions in the Entry.

Fields

num_hashes: u64

The number of hashes since the previous Entry ID.

hash: Hash

The SHA-256 hash num_hashes after the previous Entry ID.

transactions: Vec<VersionedTransaction>

An unordered list of transactions that were observed before the Entry ID was generated. They may have been observed before a previous Entry ID but were pushed back into this list to ensure deterministic interpretation of the ledger.

Implementations

impl Entry

pub fn new( prev_hash: &Hash, num_hashes: u64, transactions: Vec<Transaction> ) -> Self

Creates the next Entry num_hashes after start_hash.

pub fn new_mut( start_hash: &mut Hash, num_hashes: &mut u64, transactions: Vec<Transaction> ) -> Self

pub fn verify(&self, start_hash: &Hash) -> bool

Verifies self.hash is the result of hashing a start_hash self.num_hashes times. If the transaction is not a Tick, then hash that as well.

pub fn is_tick(&self) -> bool

Trait Implementations

impl Clone for Entry

fn clone(&self) -> Entry

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Entry

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

Formats the value using the given formatter.

impl Default for Entry

fn default() -> Entry

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Entry

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&Entry> for EntrySummary

fn from(entry: &Entry) -> Self

Converts to this type from the input type.

impl PartialEq for Entry

fn eq(&self, other: &Entry) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Entry

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Entry

impl StructuralPartialEq for Entry