Struct Commit 

pub struct Commit {
    pub did: String,
    pub version: i64,
    pub data: Cid,
    pub rev: String,
    pub prev: Option<Cid>,
}

A commit before it is signed.

The field names are the protocol’s, and every one of them is signed: a reader that trusted did from anywhere but inside the signature would accept one account’s commit as another’s.

Fields

did: String

The repository this is a commit for.

version: i64

The repository format. Always REPO_VERSION here.

data: Cid

The root of the Merkle search tree over every record.

rev: String

A TID that increases with every commit to this repository.

It is what lets a consumer order two commits it received out of order, and what a since cursor is compared against. It is a string here rather than a parsed TID because this crate does not mint one — the caller does, out of the same clock its record keys come from.

prev: Option<Cid>

The commit this one replaces, or None for the first.

Implementations

impl Commit

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

The bytes a signature is made over: every field except sig.

A signature over the signed commit would be a signature over itself, so the field is absent rather than null or empty. That means the block that is hashed for the CID and the block that is signed are two different encodings of the same commit, which is the one thing about this format that reliably surprises people, and why it is a named method rather than a step inside sign.

pub fn sign(self, key: &SigningKey) -> SignedCommit

Signs the commit.

The signature is deterministic — k256 uses RFC 6979 nonces — so the same repository state signed by the same key twice gives the same bytes and the same commit CID. That is what makes an export reproducible, and it is a property of the key crate rather than of anything decided here.

fn to_value(&self, signature: Option<&[u8; 64]>) -> Value

The commit as a data-model value, with or without its signature.

Trait Implementations

impl Clone for Commit

fn clone(&self) -> Commit

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Commit

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

Formats the value using the given formatter.

impl PartialEq for Commit

fn eq(&self, other: &Commit) -> 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 Eq for Commit

impl StructuralPartialEq for Commit