type Entry struct {
	// Data holds the data that the log commits to.
	Data []byte
	// Extra holds data that is attached to the entry, but not committed to by
	// the log, i.e. not accounted for when calculating Merkle tree hashes.
	Extra []byte
	// Hash is the Merkle tree leaf hash of the log entry Data.
	Hash []byte
}

type Node struct {
	ID   compact.NodeID
	Hash []byte
}

type SequenceReader interface {
	// Read fetches the specified [begin, end) range of entries, and returns them
	// in order. May return a prefix of the requested range (potentially empty).
	Read(ctx context.Context, begin, end uint64) ([]Entry, error)
}

type SequenceWriter interface {
	// Write stores all the passed-in entries to the sequence starting at the
	// specified begin index.
	Write(ctx context.Context, begin uint64, entries []Entry) error
}

type TreeReader interface {
	// Read fetches and returns the Merkle tree hashes of the specified nodes
	// from the storage. It is expected that the number of nodes is relatively
	// small, e.g. O(log N) for vertical proof-like reads. The returned slice
	// contains nil hashes for the nodes that are not found.
	Read(ctx context.Context, ids []compact.NodeID) ([][]byte, error)
}

type TreeWriter interface {
	// Write stores all the passed in nodes of the Merkle tree. It must never be
	// called with the same node ID, but different hashes. This call may succeed
	// only partially and leave side effects, so the caller must ensure that they
	// can reliably reconstruct and retry the request even if they fail/restart.
	Write(ctx context.Context, nodes []Node) error
}