miden_node_proto/domain/
block.rs

1use miden_objects::{
2    block::{BlockHeader, BlockNumber},
3    crypto::merkle::MerklePath,
4};
5
6use crate::{
7    errors::{ConversionError, MissingFieldHelper},
8    generated::block as proto,
9};
10
11// BLOCK HEADER
12// ================================================================================================
13
14impl From<&BlockHeader> for proto::BlockHeader {
15    fn from(header: &BlockHeader) -> Self {
16        Self {
17            version: header.version(),
18            prev_hash: Some(header.prev_hash().into()),
19            block_num: header.block_num().as_u32(),
20            chain_root: Some(header.chain_root().into()),
21            account_root: Some(header.account_root().into()),
22            nullifier_root: Some(header.nullifier_root().into()),
23            note_root: Some(header.note_root().into()),
24            tx_hash: Some(header.tx_hash().into()),
25            kernel_root: Some(header.kernel_root().into()),
26            proof_hash: Some(header.proof_hash().into()),
27            timestamp: header.timestamp(),
28        }
29    }
30}
31
32impl From<BlockHeader> for proto::BlockHeader {
33    fn from(header: BlockHeader) -> Self {
34        (&header).into()
35    }
36}
37
38impl TryFrom<&proto::BlockHeader> for BlockHeader {
39    type Error = ConversionError;
40
41    fn try_from(value: &proto::BlockHeader) -> Result<Self, Self::Error> {
42        value.try_into()
43    }
44}
45
46impl TryFrom<proto::BlockHeader> for BlockHeader {
47    type Error = ConversionError;
48
49    fn try_from(value: proto::BlockHeader) -> Result<Self, Self::Error> {
50        Ok(BlockHeader::new(
51            value.version,
52            value
53                .prev_hash
54                .ok_or(proto::BlockHeader::missing_field(stringify!(prev_hash)))?
55                .try_into()?,
56            value.block_num.into(),
57            value
58                .chain_root
59                .ok_or(proto::BlockHeader::missing_field(stringify!(chain_root)))?
60                .try_into()?,
61            value
62                .account_root
63                .ok_or(proto::BlockHeader::missing_field(stringify!(account_root)))?
64                .try_into()?,
65            value
66                .nullifier_root
67                .ok_or(proto::BlockHeader::missing_field(stringify!(nullifier_root)))?
68                .try_into()?,
69            value
70                .note_root
71                .ok_or(proto::BlockHeader::missing_field(stringify!(note_root)))?
72                .try_into()?,
73            value
74                .tx_hash
75                .ok_or(proto::BlockHeader::missing_field(stringify!(tx_hash)))?
76                .try_into()?,
77            value
78                .kernel_root
79                .ok_or(proto::BlockHeader::missing_field(stringify!(kernel_root)))?
80                .try_into()?,
81            value
82                .proof_hash
83                .ok_or(proto::BlockHeader::missing_field(stringify!(proof_hash)))?
84                .try_into()?,
85            value.timestamp,
86        ))
87    }
88}
89
90/// Data required to verify a block's inclusion proof.
91#[derive(Clone, Debug)]
92pub struct BlockInclusionProof {
93    pub block_header: BlockHeader,
94    pub mmr_path: MerklePath,
95    pub chain_length: BlockNumber,
96}
97
98impl From<BlockInclusionProof> for proto::BlockInclusionProof {
99    fn from(value: BlockInclusionProof) -> Self {
100        Self {
101            block_header: Some(value.block_header.into()),
102            mmr_path: Some((&value.mmr_path).into()),
103            chain_length: value.chain_length.as_u32(),
104        }
105    }
106}
107
108impl TryFrom<proto::BlockInclusionProof> for BlockInclusionProof {
109    type Error = ConversionError;
110
111    fn try_from(value: proto::BlockInclusionProof) -> Result<Self, ConversionError> {
112        let result = Self {
113            block_header: value
114                .block_header
115                .ok_or(proto::BlockInclusionProof::missing_field("block_header"))?
116                .try_into()?,
117            mmr_path: (&value
118                .mmr_path
119                .ok_or(proto::BlockInclusionProof::missing_field("mmr_path"))?)
120                .try_into()?,
121            chain_length: value.chain_length.into(),
122        };
123
124        Ok(result)
125    }
126}