Struct DigDataStoreMetadata 

pub struct DigDataStoreMetadata {
    pub root_hash: BytesImpl<32>,
    pub label: Option<String>,
    pub description: Option<String>,
    pub size_proof: Option<String>,
    pub program_hash: Option<BytesImpl<32>>,
    pub size_bucket: Option<SizeBucket>,
}

The DIG DataLayer metadata: the SDK’s DataStoreMetadata shape with the exact byte count ("b") REPLACED by a power-of-2 size_bucket ("sz"), plus the additive program_hash ("p").

This is the metadata dig-merkle curries into a minted store. The DIG store size is expressed as a coarse power-of-2 SizeBucket rather than an exact byte count — a clean replacement of the SDK’s bytes/"b" field (pre-release: there are NO on-chain DIG stores carrying "b"). With size_bucket == None && program_hash == None it serializes byte-identically to the SDK’s DataStoreMetadata with bytes == None (it emits l/d/sp only, never "b") — an SDK-typed reader parses it and simply ignores the unknown "sz"/"p" keys (SPEC §8/§9).

Fields

root_hash: BytesImpl<32>

The anchored .dig merkle root — always the first metadata atom (SPEC §8).

label: Option<String>

An optional human-readable store label (CLVM alist key "l").

description: Option<String>

An optional human-readable store description (CLVM alist key "d").

size_proof: Option<String>

An optional size-proof string (CLVM alist key "sp").

program_hash: Option<BytesImpl<32>>

The optional CLVM tree-hash of the program/puzzle this store is associated with (CLVM alist key "p", appended after "sp"). dig-merkle stores and echoes this value; it never computes it.

size_bucket: Option<SizeBucket>

The optional .dig store size as a power-of-2 bucket (CLVM alist key "sz", appended LAST — after "p"). This REPLACES the SDK’s exact-byte "b" field: dig-merkle never emits "b", and the size is this coarse bucket instead. Encoded on-wire as the minimal 1-byte bucket exponent k ∈ 0..=10 (empty atom for k = 0), so a None size emits no key at all. See SizeBucket.

Trait Implementations

impl Clone for DigDataStoreMetadata

fn clone(&self) -> DigDataStoreMetadata

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DigDataStoreMetadata

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

Formats the value using the given formatter.

impl Default for DigDataStoreMetadata

fn default() -> DigDataStoreMetadata

Returns the “default value” for a type.

impl Eq for DigDataStoreMetadata

impl<N, D> FromClvm<D> for DigDataStoreMetadata

where D: ClvmDecoder<Node = N>,

Decodes (root_hash . items), reading l/d/sp/p/sz and IGNORING any other key (the same _ => () tolerance as the SDK).

There is deliberately NO "b" arm. Every DIG capsule store ALWAYS carries "sz" (dig-merkle writes it), so "sz" is the authoritative size. A foreign SDK DataLayer store’s exact-byte "b" is NOT a DIG size-proof — fabricating a bucket from it would misrepresent a non-capsule — so "b" falls to the unknown-key tolerance and is ignored, and a sz-free store decodes honestly with size_bucket == None. This does NOT break reading SDK stores: they still DECODE fine (root/l/d/sp parse, "b" skipped). A p-free store likewise decodes with program_hash == None (SPEC §5.1).

fn from_clvm( decoder: &D, node: N, ) -> Result<DigDataStoreMetadata, FromClvmError>

impl MetadataWithRootHash for DigDataStoreMetadata

The SDK’s generic build_datastore/from_spend require this bound to recover the anchored root. root_hash_only clears every optional field — including program_hash and size_bucket — to None.

fn root_hash(&self) -> BytesImpl<32>

fn root_hash_only(root_hash: BytesImpl<32>) -> DigDataStoreMetadata

impl PartialEq for DigDataStoreMetadata

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for DigDataStoreMetadata

impl<N, E> ToClvm<E> for DigDataStoreMetadata

where E: ClvmEncoder<Node = N>,

Encodes (root_hash . items) where items pushes l/d/sp (mirroring the SDK, but NEVER the exact-byte "b" key), then appends ("p" . program_hash) and finally ("sz" . exponent) LAST, each only when Some.

Never emitting "b" and appending the DIG keys only when present is the byte-identity guarantee: with program_hash == None && size_bucket == None the bytes equal the SDK’s DataStoreMetadata with bytes == None (SPEC §9).

fn to_clvm(&self, encoder: &mut E) -> Result<N, ToClvmError>