What is a Solana entry?

3 fields form an entry

A Solana entry contains a hash-count value, a resulting hash, and a transaction vector. Its first two fields advance and commit PoH order; the vector records work associated with that point.

An entry is larger than a transaction and smaller than the conceptual block. One entry can contain several transactions. Another can contain none and serve as a tick. A slot contains an ordered sequence of entries.

Raw data shreds do not preserve one-entry-per-packet alignment. The leader serializes vectors of entries, and the shredder slices the resulting bytes into packet-sized regions. Recovering entry objects therefore requires framing across shred boundaries.

Entries connect time and work

Proof of History forms a sequential hash chain. Hash count states how much chain progress occurred since the prior recorded point. Entry hash commits the resulting sequence state and, for transaction-bearing records, the associated transaction information according to protocol rules.

This gives replay an ordered ledger. Transactions are not a bag attached to a slot number. They appear at defined points in a verifiable sequence produced by the leader.

The sequence is cryptographic time, not a precise UTC timestamp. A receiver should store local arrival time separately. Entry position and hash progression establish ledger order, while a monotonic clock measures network and decoder latency.

Tick entries can contain zero transactions

Ticks are transaction-free entries that advance Proof of History. They mark slot progress and support replay's timing and completion rules.

An empty transaction vector does not mean the entry is useless padding. Its hash count and resulting hash are part of the ledger sequence. Dropping all empty entries before verification can break chain continuity and tick accounting.

Applications interested only in transactions may omit tick events from their downstream business stream after the protocol decoder has processed them. The ledger layer should still retain or validate the information needed for sequence correctness.

Transaction entries can hold several messages

The transaction vector can contain multiple versioned transactions. Their order inside the entry is part of the leader's recorded sequence.

Each transaction has signatures and a message. The message references accounts, instructions, a recent blockhash, and possibly address lookup tables depending on version. Execution results are not embedded as settled state in the raw entry.

A low-latency parser can emit proposed transaction messages as soon as the complete entry batch is decoded. Preserve slot plus both nested positions, entry then transaction, and receive timing so later reconciliation can locate the same item precisely.

Serialization precedes shredding

The leader produces entries, serializes a vector of them using the ledger's expected encoding, and passes the byte stream to the shredder. The shredder fills data-shred capacity and emits completion flags at serialized-vector boundaries.

This ordering explains why a shred has no independent transaction count. The header knows bytes and boundaries, not application objects. A transaction-length prefix can itself be split across packets.

Receivers concatenate only meaningful data bytes in increasing data-index order. They stop at DATA_COMPLETE, then deserialize the complete vector. Decoding each shred tail independently will fail on ordinary boundary placements.

DATA_COMPLETE supplies a framing boundary

The packet carrying DATA_COMPLETE finishes a serialized entry batch. This supplies a safe boundary for ordinary batch deserialization.

Suppose a vector begins in data index 64 and ends at index 69. All six meaningful payloads are concatenated in order. The decoder does not include header bytes, zero padding, Merkle proofs, or later index 70.

Several vectors can occupy one slot. Incremental decoding exposes early transactions while later entries remain in production. LAST_IN_SLOT ends the final vector and also implies data completion.

FEC repairs bytes before entry parsing

A missing data shred creates a hole in the serialized vector. Later bytes cannot be shifted left or parsed around the gap because length prefixes and object bodies may cross it.

The FEC lane groups data and coding shreds, reaches the source threshold, reconstructs the missing source packet, and validates it. Ordered assembly inserts the recovered bytes at the proper data index.

Only then does entry deserialization proceed. Reed-Solomon understands shard positions, not entries or transactions. The entry decoder understands serialization, not parity. Keeping the layers separate makes failures attributable.

Entry hash verification has context

Parsing an entry returns fields. Verifying its Proof of History relationship requires the preceding hash state and protocol rules. A receiver that joins mid-stream may decode transaction objects before it has enough context to verify the complete chain.

Expose parsed and chain_verified as separate states. Some latency-sensitive applications act on authenticated leader data before full PoH verification, but the distinction must remain visible.

When full ledger correctness matters, replay verifies the entry sequence, tick counts, hashes, and execution against parent state. A raw parser should not claim that deserialization alone performed validator replay.

Entry order has two levels

Data indexes order serialized bytes. After decoding, vector position orders entries within the batch. Transaction vector position orders transactions within each entry.

Persist three coordinates: slot and the ordinals for entry and transaction. Data-shred ranges are useful provenance, especially when diagnosing a late or recovered transaction, but they are not a stable one-to-one transaction identifier.

Transaction signatures provide another lookup key, yet the same signed transaction can be observed in more than one proposed slot or fork. Context remains necessary for event identity.

Entry bytes do not contain outcomes

Raw entries carry transaction messages proposed by the leader. They do not carry the final RPC-style execution metadata a trading application may expect, such as settled status, logs, compute units consumed, or post-account balances.

Those results emerge during replay. A transaction can be syntactically valid and correctly signed but fail when executed against the slot's bank state. Its containing proposal may also never confirm.

Early consumers often decode instructions and estimate effects, then reconcile against executed data. The estimate should be labeled predicted or proposed. Treating it as a confirmed state transition creates inventory and risk errors.

Address lookup adds state dependence

Versioned transactions can refer to addresses stored in lookup table accounts rather than include every account key directly in the message. The entry carries the transaction, but resolving all effective account keys can require account state.

A raw parser without a current lookup-table cache can still identify signature, message version, directly encoded keys, and address-table references. It cannot produce a complete account list from packet bytes alone.

Cache state must match the relevant fork and slot context. Using the latest confirmed lookup table for an earlier proposed transaction can resolve the wrong addresses if the table changed. Fast decoding and state-correct resolution are different stages.

Entry batching is an implementation boundary

The vector boundary marked by DATA_COMPLETE is useful for serialization and streaming. It is not necessarily a semantic block subdivision recognized by applications.

Consecutive vectors remain within one slot and PoH stream. A consumer should continue entry ordinals across batches. Resetting position at every DATA_COMPLETE boundary loses slot-wide order.

Batch size can vary with leader production, buffering, and packet capacity. Do not assume one vector per FEC set, one vector per tick range, or one transaction count per batch. Read actual flags and decoded lengths.

Parser failures need byte provenance

When deserialization fails, record slot, the batch's first and final data indexes, relevant variant mix, direct versus recovered members, declared sizes, and a bounded hash of concatenated bytes.

A missing index should have blocked the batch before parsing. Failure with a gap-free range can indicate wrong payload boundaries, unsupported format, corrupt recovery, conflicting views, or a decoder mismatch.

Avoid logging full transaction bytes at line rate. Captures can contain sensitive strategy activity before confirmation and consume large storage. Bounded samples and reproducible packet hashes usually provide safer operational evidence.

Entries remain provisional until replay

Leader signature validation attributes the shreds. FEC restores missing source bytes. Entry deserialization recovers ledger objects. Proof of History verification checks sequence. Transaction execution produces outcomes. Consensus chooses and roots a fork.

Each stage strengthens a different claim. None should borrow the name of a later stage.

For MEV and HFT systems, the early stage is valuable precisely because it precedes certainty. A disciplined pipeline can act on proposed transactions with an explicit probability model and later reconcile. An undisciplined one mistakes serialization success for settled state.

Incremental parsing needs rollback rules

A specialized decoder can examine a completed prefix of the serialization buffer before DATA_COMPLETE, but ordinary vector framing makes speculative parsing delicate. The vector length and later bytes can remain unavailable, and an entry body can cross the latest shred boundary.

If the parser retains partial state, it must record the exact data index and byte offset consumed. A recovered earlier shred or authenticated conflicting view invalidates state derived from a different byte sequence. Rollback means discarding parsed objects and re-running from the last fully committed serialization boundary, not patching object fields in place.

The safest general contract remains batch-based: no object emission until consecutive bytes reach DATA_COMPLETE and the complete vector deserializes. Latency-critical implementations can add a speculative lane, but its events need a speculative flag and a correction channel.

Bounds apply even to authenticated leader data. Validate vector lengths against available batch bytes before allocating. Cap entry and transaction collections according to the supported implementation. Ensure the decoder consumes the intended buffer and does not accept unexplained trailing bytes.

Fuzz tests should split valid serialized entries at every possible shred byte boundary. Remove each source packet in turn, reconstruct it through FEC, and confirm identical entry objects. Corrupt length prefixes under a valid test key to exercise authenticated malformed input.

This work is less visible than program instruction decoding, but it defines trust in every later object. A fast program decoder cannot repair an entry vector framed from the wrong shred boundary.

Entry output should retain provenance

Each decoded entry should carry cluster context, slot, block view, slot-wide ordinal, source batch range, authentication state, and whether any contributing data shred was recovered. Transactions inherit those coordinates.

Provenance does not change entry bytes. It explains how and when the receiver obtained them. A recovered flag can reveal that one FEC operation delayed 30 transactions. A block-view root can prevent an application from merging entries from conflicting leader commitments.

Avoid attaching entire packet arrays to every transaction. Store shared batch provenance once and reference it with a compact identifier. Keep raw bytes under a bounded diagnostic retention policy.

When later replay confirms the entry sequence, append verification and commitment observations. Do not replace first-seen time or initial proposal status. Both are needed to compare early data with eventual ledger truth.

This record design makes correction possible. If a speculative parser emitted an object from a view later rejected, downstream consumers receive an explicit retraction keyed to the original provenance instead of an unexplained disappearance.