Struct Manifest 

pub struct Manifest { /* private fields */ }

The root metadata structure for a bucket.

A manifest contains everything needed to access and verify a bucket:

• Identity: Global UUID and human-readable name
• Access control: Principal shares for decryption
• Content pointers: Links to entry node, pin set, and crdt op log
• Version chain: Previous link and height for history
• Publication: Optional plaintext secret for public access

Serialization

Manifests are serialized using DAG-CBOR and stored as content-addressed blobs. The manifest’s CID serves as the bucket’s current state identifier.

Example

let manifest = Manifest::new(
    Uuid::new_v4(),
    "my-bucket".to_string(),
    owner_public_key,
    secret_share,
    entry_link,
    pins_link,
    0, // initial height
);

Implementations

impl Manifest

pub fn new( id: Uuid, name: String, owner: PublicKey, share: SecretShare, entry: Link, pins: Link, height: u64, ) -> Self

Create a new manifest with an initial owner.

Arguments

• id - Global unique identifier for the bucket
• name - Human-readable display name
• owner - Public key of the initial owner
• share - Encrypted secret share for the owner
• entry - Link to the root node
• pins - Link to the pin set
• height - Version chain height (usually 0 for new buckets)

pub fn id(&self) -> &Uuid

Get the bucket’s unique identifier.

pub fn name(&self) -> &str

Get the bucket’s display name.

pub fn version(&self) -> &Version

Get the software version.

pub fn entry(&self) -> &Link

Get the entry node link.

pub fn pins(&self) -> &Link

Get the pins link.

pub fn previous(&self) -> &Option<Link>

Get the previous manifest link.

pub fn height(&self) -> u64

Get the version chain height.

pub fn ops_log(&self) -> Option<&Link>

Get the operations log link.

pub fn shares(&self) -> &BTreeMap<String, Share>

Get all shares.

pub fn shares_mut(&mut self) -> &mut BTreeMap<String, Share>

Get mutable access to shares.

pub fn get_share(&self, public_key: &PublicKey) -> Option<&Share>

Get a principal’s share by their public key.

pub fn get_peer_ids(&self) -> Vec<PublicKey>

Get all peer public keys from shares.

pub fn get_shares_by_role(&self, role: PrincipalRole) -> Vec<&Share>

Get all shares with a specific role.

pub fn is_published(&self) -> bool

Check if the bucket is published.

Published buckets have their secret stored in plaintext, allowing anyone with the manifest to decrypt contents.

pub fn public(&self) -> Option<&Secret>

Get the public secret if available.

pub fn author(&self) -> Option<&PublicKey>

Get the author (signer’s public key) if the manifest is signed.

pub fn signature(&self) -> Option<&Signature>

Get the signature if the manifest is signed.

pub fn is_signed(&self) -> bool

Check if the manifest has been signed.

pub fn set_entry(&mut self, entry: Link)

Set the entry node link.

pub fn set_pins(&mut self, pins_link: Link)

Set the pins link.

pub fn set_previous(&mut self, previous: Link)

Set the previous manifest link.

pub fn set_height(&mut self, height: u64)

Set the version chain height.

pub fn set_ops_log(&mut self, link: Link)

Set the operations log link.

pub fn clear_ops_log(&mut self)

Clear the operations log link.

This should be called when creating a new version from an existing manifest, since each version has its own independent ops_log.

pub fn add_share(&mut self, share: Share)

Add a share to the manifest.

Use Share::new_owner or Share::new_mirror to construct the share.

pub fn publish(&mut self, secret: &Secret)

Publish the bucket by storing the secret in plaintext.

Warning: Once published, this version’s secret is exposed and anyone with the manifest can decrypt bucket contents.

pub fn unpublish(&mut self)

Unpublish the bucket by clearing the public secret.

This removes public read access. Mirrors will no longer be able to decrypt bucket contents until republished.

pub fn sign(&mut self, secret_key: &SecretKey) -> Result<(), ManifestError>

Sign this manifest with the given secret key.

Sets the author field to the public key and signature to the Ed25519 signature over the manifest’s signable bytes.

Errors

Returns an error if the manifest cannot be serialized for signing.

pub fn verify_signature(&self) -> Result<bool, ManifestError>

Verify the manifest’s signature.

Returns Ok(true) if the signature is valid, Ok(false) if the manifest is unsigned (no author or signature), and an error if verification fails.

Errors

Returns an error if:

• The manifest cannot be serialized for verification
• The signature is invalid (tampered or wrong key)

Trait Implementations

impl BlockEncoded<DagCborCodec> for Manifest

fn encode(&self) -> Result<Vec<u8>, CodecError>

fn decode(data: &[u8]) -> Result<Self, CodecError>

fn codec(&self) -> u64

impl Clone for Manifest

fn clone(&self) -> Manifest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Manifest

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Manifest

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Manifest

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for Manifest

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Manifest