miden_objects/conversion/
protocol_config.rs

1use alloc::format;
2use alloc::vec::Vec;
3
4use miden_protocol::Word;
5use miden_protocol::asset::AssetId;
6use miden_protocol::protocol_config::{
7    KernelConfig,
8    ProofSecurityPolicy,
9    ProofVerificationConfig,
10    ProtocolConfig,
11};
12
13use super::{MessageDecodeExt, required};
14use crate::{ConversionError, ConversionResultExt, proto};
15
16impl TryFrom<proto::protocol_config::KernelConfig> for KernelConfig {
17    type Error = ConversionError;
18
19    fn try_from(message: proto::protocol_config::KernelConfig) -> Result<Self, Self::Error> {
20        let decoder = message.decoder();
21        let main_proc = required!(decoder, message.main_proc)?;
22        let kernel_procs = message
23            .kernel_procs
24            .into_iter()
25            .enumerate()
26            .map(|(index, root)| Word::try_from(root).context(format!("kernel_procs[{index}]")))
27            .collect::<Result<Vec<_>, _>>()?;
28
29        KernelConfig::new(main_proc, kernel_procs).map_err(ConversionError::new)
30    }
31}
32
33impl From<&KernelConfig> for proto::protocol_config::KernelConfig {
34    fn from(config: &KernelConfig) -> Self {
35        Self {
36            main_proc: Some(config.main_proc().into()),
37            kernel_procs: config.kernel_procs().iter().copied().map(Into::into).collect(),
38        }
39    }
40}
41
42impl From<KernelConfig> for proto::protocol_config::KernelConfig {
43    fn from(config: KernelConfig) -> Self {
44        (&config).into()
45    }
46}
47
48impl TryFrom<proto::protocol_config::ProofSecurityPolicy> for ProofSecurityPolicy {
49    type Error = ConversionError;
50
51    fn try_from(message: proto::protocol_config::ProofSecurityPolicy) -> Result<Self, Self::Error> {
52        let decoder = message.decoder();
53        let security_estimator_root = required!(decoder, message.security_estimator_root)?;
54        let minimum_bits = u8::try_from(message.minimum_bits).context("minimum_bits")?;
55
56        ProofSecurityPolicy::new(security_estimator_root, minimum_bits)
57            .map_err(ConversionError::new)
58    }
59}
60
61impl From<&ProofSecurityPolicy> for proto::protocol_config::ProofSecurityPolicy {
62    fn from(policy: &ProofSecurityPolicy) -> Self {
63        Self {
64            security_estimator_root: Some(policy.security_estimator_root().into()),
65            minimum_bits: u32::from(policy.minimum_bits()),
66        }
67    }
68}
69
70impl From<ProofSecurityPolicy> for proto::protocol_config::ProofSecurityPolicy {
71    fn from(policy: ProofSecurityPolicy) -> Self {
72        (&policy).into()
73    }
74}
75
76impl TryFrom<proto::protocol_config::ProofVerificationConfig> for ProofVerificationConfig {
77    type Error = ConversionError;
78
79    fn try_from(
80        message: proto::protocol_config::ProofVerificationConfig,
81    ) -> Result<Self, Self::Error> {
82        let decoder = message.decoder();
83        let vm_verifier_root = required!(decoder, message.vm_verifier_root)?;
84        let precompile_verifier_root = required!(decoder, message.precompile_verifier_root)?;
85        let security_policy = required!(decoder, message.security_policy)?;
86
87        Ok(ProofVerificationConfig::new(
88            vm_verifier_root,
89            precompile_verifier_root,
90            security_policy,
91        ))
92    }
93}
94
95impl From<&ProofVerificationConfig> for proto::protocol_config::ProofVerificationConfig {
96    fn from(config: &ProofVerificationConfig) -> Self {
97        Self {
98            vm_verifier_root: Some(config.vm_verifier_root().into()),
99            precompile_verifier_root: Some(config.precompile_verifier_root().into()),
100            security_policy: Some(config.security_policy().into()),
101        }
102    }
103}
104
105impl From<ProofVerificationConfig> for proto::protocol_config::ProofVerificationConfig {
106    fn from(config: ProofVerificationConfig) -> Self {
107        (&config).into()
108    }
109}
110
111impl TryFrom<proto::protocol_config::ProtocolConfig> for ProtocolConfig {
112    type Error = ConversionError;
113
114    fn try_from(message: proto::protocol_config::ProtocolConfig) -> Result<Self, Self::Error> {
115        let decoder = message.decoder();
116        let fee_asset_id: Word = required!(decoder, message.fee_asset_id)?;
117        let fee_asset_id = AssetId::try_from(fee_asset_id).context("fee_asset_id")?;
118        let tx_kernel = required!(decoder, message.tx_kernel)?;
119        let batch_kernel = required!(decoder, message.batch_kernel)?;
120        let block_kernel = required!(decoder, message.block_kernel)?;
121        let proof_verification = required!(decoder, message.proof_verification)?;
122
123        ProtocolConfig::new(fee_asset_id, tx_kernel, batch_kernel, block_kernel, proof_verification)
124            .map_err(ConversionError::new)
125    }
126}
127
128impl From<&ProtocolConfig> for proto::protocol_config::ProtocolConfig {
129    fn from(config: &ProtocolConfig) -> Self {
130        Self {
131            fee_asset_id: Some(Word::from(config.fee_asset_id()).into()),
132            tx_kernel: Some(config.tx_kernel().into()),
133            batch_kernel: Some(config.batch_kernel().into()),
134            block_kernel: Some(config.block_kernel().into()),
135            proof_verification: Some(config.proof_verification().into()),
136        }
137    }
138}
139
140impl From<ProtocolConfig> for proto::protocol_config::ProtocolConfig {
141    fn from(config: ProtocolConfig) -> Self {
142        (&config).into()
143    }
144}
miden_objects/conversion/protocol_config.rs

miden_objects/conversion/
protocol_config.rs
