Struct TransparencyLog 

pub struct TransparencyLog { /* private fields */ }

Append-only Merkle log.

Maintains an internal subtree-roots cache keyed by (level, index) so Self::inclusion_proof runs in O(log n) instead of O(n) (issue #36). The cache is in-memory only — no on-disk format change.

subtree_roots[level][j] is the hash of the COMPLETE 2^level subtree covering leaves [j*2^level, (j+1)*2^level). Only fully-populated subtrees are stored; partial right-edge subtrees are recomputed on demand from the cached children (still O(log n) total).

Implementations

impl TransparencyLog

pub fn new() -> Self

Construct an empty log with no operator master key set.

pub fn set_operator(&mut self, master_key: VerifyingKey)

Register the operator master key used to verify STHs.

pub fn tree_size(&self) -> u64

Number of leaves currently in the log.

pub fn root_hash(&self) -> [u8; 32]

Current Merkle root hash. Returns the empty-tree sentinel when the log has no entries.

Uses the subtree-roots cache (issue #36): O(log n) for any tree size, vs O(n) before the cache.

pub fn entry(&self, index: u64) -> Option<&LogEntry>

Look up the entry at index, if any.

pub fn entries(&self) -> &[LogEntry]

All entries in log order.

pub fn leaf_hash_at(&self, index: u64) -> Option<[u8; 32]>

Return the stored leaf hash for the entry at index, if any.

Pairs with Self::inclusion_proof and verify_inclusion_proof: a verifier holding only the log and a pinned root hash can verify any entry’s inclusion without needing the original payload bytes.

Returns None when index >= tree_size() or when index does not fit in usize.

pub fn append( &mut self, kind: LogEntryKind, payload: &[u8], timestamp_version: u64, ) -> Result<u64>

Append a new leaf and return its sequence number.

Errors

Returns Err on arithmetic overflow of the sequence counter (unreachable in practice below 2^64 entries).

pub fn inclusion_proof(&self, leaf_index: u64) -> Result<InclusionProof>

Generate an inclusion proof for the leaf at leaf_index.

Errors

Returns Err if leaf_index >= tree_size.

pub fn canonical_tree_head(&self) -> Vec<u8>

Canonical bytes of the current tree head, used as the message the operator signs.

pub fn sign_tree_head(&self, operator_key: &SigningKey) -> SignedTreeHead

Produce a SignedTreeHead for the current state.

pub fn verify_tree_head(&self, sth: &SignedTreeHead) -> Result<()>

Verify a SignedTreeHead against the registered operator master key and against the log’s current root.

Errors

Returns Err if no operator is registered, if the signature does not verify, or if the STH’s root_hash does not match the log’s current root.

Trait Implementations

impl Debug for TransparencyLog

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

Formats the value using the given formatter.

impl Default for TransparencyLog

fn default() -> TransparencyLog

Returns the “default value” for a type.