bc-xid 0.22.0

Unique, stable, extensible, and verifiable identifiers
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

use dcbor::prelude::CBORError;
use thiserror::Error;

#[derive(Debug, Error)]
pub enum Error {
    #[error("duplicate item: {item}")]
    Duplicate { item: String },

    #[error("item not found: {item}")]
    NotFound { item: String },

    #[error("item is still referenced: {item}")]
    StillReferenced { item: String },

    #[error("invalid or empty value: {field}")]
    EmptyValue { field: String },

    #[error("unknown privilege")]
    UnknownPrivilege,

    #[error("invalid XID")]
    InvalidXid,

    #[error("missing inception key")]
    MissingInceptionKey,

    #[error("invalid resolution method")]
    InvalidResolutionMethod,

    #[error("multiple provenance marks")]
    MultipleProvenanceMarks,

    #[error("unexpected predicate: {predicate}")]
    UnexpectedPredicate { predicate: String },

    #[error("unexpected nested assertions")]
    UnexpectedNestedAssertions,

    #[error("no permissions in service '{uri}'")]
    NoPermissions { uri: String },

    #[error("no key or delegate references in service '{uri}'")]
    NoReferences { uri: String },

    #[error("unknown key reference {reference} in service '{uri}'")]
    UnknownKeyReference { reference: String, uri: String },

    #[error("unknown delegate reference {reference} in service '{uri}'")]
    UnknownDelegateReference { reference: String, uri: String },

    #[error("key not found in XID document: {key}")]
    KeyNotFoundInDocument { key: String },

    #[error("delegate not found in XID document: {delegate}")]
    DelegateNotFoundInDocument { delegate: String },

    #[error("invalid password")]
    InvalidPassword,

    #[error("envelope is not signed")]
    EnvelopeNotSigned,

    #[error("signature verification failed")]
    SignatureVerificationFailed,

    #[error("no provenance mark to advance")]
    NoProvenanceMark,

    #[error(
        "document already has generator, cannot provide external generator"
    )]
    GeneratorConflict,

    #[error(
        "document does not have generator, must provide external generator"
    )]
    NoGenerator,

    #[error("generator chain ID mismatch: expected {}, got {}", hex::encode(.expected), hex::encode(.actual))]
    ChainIdMismatch { expected: Vec<u8>, actual: Vec<u8> },

    #[error("generator sequence mismatch: expected {expected}, got {actual}")]
    SequenceMismatch { expected: u32, actual: u32 },

    #[error("envelope parsing error")]
    EnvelopeParsing(#[from] bc_envelope::Error),

    #[error("component error")]
    Component(#[from] bc_components::Error),

    #[error("CBOR error")]
    Cbor(#[from] CBORError),

    #[error("provenance mark error")]
    ProvenanceMark(#[from] provenance_mark::Error),
}

pub type Result<T> = std::result::Result<T, Error>;