miden-objects 0.17.0-rc.6

Canonical Protobuf representations for Miden protocol objects
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

pub use proto::transaction::DecodedInputNoteCommitment as InputNoteCommitment;

use crate::decoded::VerificationError;
use crate::{BuildUnchecked, Verify, proto};

#[cfg(test)]
mod tests;

/// Builds the decoded commitment without checking that its nullifier belongs to its note header.
/// A present header is verified, but the caller must establish nullifier/header consistency and
/// authenticate the note's inclusion separately. An absent header is not evidence of inclusion.
impl BuildUnchecked for InputNoteCommitment {
    type Output = miden_protocol::transaction::InputNoteCommitment;
    type Error = VerificationError;
    fn build_unchecked(self) -> Result<Self::Output, Self::Error> {
        Ok(Self::Output::from_parts_unchecked(
            miden_protocol::note::Nullifier::from_raw(self.nullifier),
            self.header.verify()?,
        ))
    }
}

pub use proto::transaction::DecodedPrivateOutputNote as PrivateOutputNote;

impl Verify for PrivateOutputNote {
    type Verified = miden_protocol::transaction::PrivateOutputNote;
    type Error = VerificationError;
    fn verify(self) -> Result<Self::Verified, Self::Error> {
        Ok(Self::Verified::new(self.header.verify()?, self.attachments.verify()?)?)
    }
}

pub use proto::transaction::DecodedPublicOutputNote as PublicOutputNote;

impl Verify for PublicOutputNote {
    type Verified = miden_protocol::transaction::PublicOutputNote;
    type Error = VerificationError;
    fn verify(self) -> Result<Self::Verified, Self::Error> {
        Ok(Self::Verified::new(self.note.verify()?)?)
    }
}

pub use proto::transaction::DecodedOutputNote as OutputNote;

impl Verify for OutputNote {
    type Verified = miden_protocol::transaction::OutputNote;
    type Error = VerificationError;
    fn verify(self) -> Result<Self::Verified, Self::Error> {
        use proto::transaction::output_note::DecodedNote;
        match self.note {
            DecodedNote::Public(note) => Ok(Self::Verified::Public(note.verify()?)),
            DecodedNote::Private(note) => Ok(Self::Verified::Private(note.verify()?)),
        }
    }
}

pub use proto::transaction::DecodedAuthenticatedInputNote as AuthenticatedInputNote;

/// Checks proof/note identity, not inclusion against a trusted block root.
impl Verify for AuthenticatedInputNote {
    type Verified = miden_protocol::transaction::InputNote;
    type Error = VerificationError;
    fn verify(self) -> Result<Self::Verified, Self::Error> {
        let note = self.note.verify()?;
        let (proof_id, proof) = self.proof.verify()?;
        if proof_id != note.id() {
            return Err(InputNoteError::IdMismatch {
                transmitted: proof_id,
                decoded: note.id(),
            }
            .into());
        }
        Ok(Self::Verified::authenticated(note, proof))
    }
}

#[derive(Debug, thiserror::Error)]
pub enum InputNoteError {
    #[error("note ID mismatch: transmitted {transmitted}, decoded {decoded}")]
    IdMismatch {
        transmitted: miden_protocol::note::NoteId,
        decoded: miden_protocol::note::NoteId,
    },
}

pub use proto::transaction::DecodedInputNote as InputNote;

impl Verify for InputNote {
    type Verified = miden_protocol::transaction::InputNote;
    type Error = VerificationError;
    fn verify(self) -> Result<Self::Verified, Self::Error> {
        use proto::transaction::input_note::DecodedNote;
        match self.note {
            DecodedNote::Authenticated(note) => note.verify(),
            DecodedNote::Unauthenticated(note) => {
                Ok(Self::Verified::unauthenticated(note.verify()?))
            },
        }
    }
}

pub use proto::transaction::DecodedInputNotes as InputNotes;

impl Verify for InputNotes {
    type Verified = miden_protocol::transaction::InputNotes<miden_protocol::transaction::InputNote>;
    type Error = VerificationError;
    fn verify(self) -> Result<Self::Verified, Self::Error> {
        let notes = self.notes.verify()?;
        Ok(Self::Verified::new(notes)?)
    }
}

pub use proto::transaction::DecodedRawOutputNote as RawOutputNote;

impl Verify for RawOutputNote {
    type Verified = miden_protocol::transaction::RawOutputNote;
    type Error = VerificationError;
    fn verify(self) -> Result<Self::Verified, Self::Error> {
        use proto::transaction::raw_output_note::DecodedNote;
        match self.note {
            DecodedNote::Full(note) => Ok(Self::Verified::Full(note.verify()?)),
            DecodedNote::Partial(note) => Ok(Self::Verified::Partial(note.verify()?)),
        }
    }
}

pub use proto::transaction::DecodedRawOutputNotes as RawOutputNotes;

impl Verify for RawOutputNotes {
    type Verified = miden_protocol::transaction::RawOutputNotes;
    type Error = VerificationError;
    fn verify(self) -> Result<Self::Verified, Self::Error> {
        Ok(Self::Verified::new(self.notes.verify()?)?)
    }
}