1#![no_std]
11#![cfg_attr(docsrs, feature(doc_cfg))]
12#![allow(dead_code)]
14#![deny(rustdoc::broken_intra_doc_links)]
16#![deny(missing_debug_implementations)]
17#![deny(missing_docs)]
18#![forbid(unsafe_code)]
19
20#[macro_use]
21extern crate alloc;
22
23#[cfg(feature = "std")]
24extern crate std;
25
26use alloc::vec::Vec;
27
28mod action;
29mod address;
30pub mod builder;
31pub mod bundle;
32#[cfg(feature = "circuit")]
33pub mod circuit;
34#[cfg(not(feature = "unstable-voting-circuits"))]
35mod constants;
36#[cfg(feature = "unstable-voting-circuits")]
37pub mod constants;
38pub mod keys;
39pub mod note;
40pub mod note_encryption;
41pub mod pczt;
42pub mod primitives;
43#[cfg(not(feature = "unstable-voting-circuits"))]
44mod spec;
45#[cfg(feature = "unstable-voting-circuits")]
46pub mod spec;
47pub mod tree;
48pub mod value;
49pub mod zip32;
50
51#[cfg(test)]
52mod test_vectors;
53
54#[cfg(all(test, feature = "circuit"))]
57struct CachedTestKeys {
58 circuit_version: circuit::OrchardCircuitVersion,
59 proving_key: std::sync::OnceLock<circuit::ProvingKey>,
60 verifying_key: std::sync::OnceLock<circuit::VerifyingKey>,
61}
62
63#[cfg(all(test, feature = "circuit"))]
64impl CachedTestKeys {
65 const fn new(circuit_version: circuit::OrchardCircuitVersion) -> Self {
66 Self {
67 circuit_version,
68 proving_key: std::sync::OnceLock::new(),
69 verifying_key: std::sync::OnceLock::new(),
70 }
71 }
72
73 fn proving_key(&self) -> &circuit::ProvingKey {
74 self.proving_key
75 .get_or_init(|| circuit::ProvingKey::build(self.circuit_version))
76 }
77
78 fn verifying_key(&self) -> &circuit::VerifyingKey {
79 self.verifying_key
80 .get_or_init(|| circuit::VerifyingKey::build(self.circuit_version))
81 }
82}
83
84#[cfg(all(test, feature = "circuit"))]
85fn cached_test_keys(circuit_version: circuit::OrchardCircuitVersion) -> &'static CachedTestKeys {
86 use circuit::OrchardCircuitVersion;
87
88 static INSECURE: CachedTestKeys = CachedTestKeys::new(OrchardCircuitVersion::InsecurePreNu6_2);
89 static FIXED: CachedTestKeys = CachedTestKeys::new(OrchardCircuitVersion::FixedPostNu6_2);
90 static POST_NU6_3: CachedTestKeys = CachedTestKeys::new(OrchardCircuitVersion::PostNu6_3);
91
92 match circuit_version {
93 OrchardCircuitVersion::InsecurePreNu6_2 => &INSECURE,
94 OrchardCircuitVersion::FixedPostNu6_2 => &FIXED,
95 OrchardCircuitVersion::PostNu6_3 => &POST_NU6_3,
96 }
97}
98
99pub use action::{Action, ActionFromPartsError};
100pub use address::Address;
101pub use bundle::Bundle;
102pub use constants::MERKLE_DEPTH_ORCHARD as NOTE_COMMITMENT_TREE_DEPTH;
103pub use constants::{L_ORCHARD_BASE, L_ORCHARD_SCALAR, L_VALUE};
104pub use note::{Note, NoteVersion};
105pub use tree::Anchor;
106
107#[derive(Clone)]
111pub struct Proof(Vec<u8>);
112
113impl core::fmt::Debug for Proof {
114 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
115 if f.alternate() {
116 f.debug_tuple("Proof").field(&self.0).finish()
117 } else {
118 f.debug_tuple("Proof")
120 .field(&format_args!("{} bytes", self.0.len()))
121 .finish()
122 }
123 }
124}
125
126impl AsRef<[u8]> for Proof {
127 fn as_ref(&self) -> &[u8] {
128 &self.0
129 }
130}
131
132impl memuse::DynamicUsage for Proof {
133 fn dynamic_usage(&self) -> usize {
134 self.0.dynamic_usage()
135 }
136
137 fn dynamic_usage_bounds(&self) -> (usize, Option<usize>) {
138 self.0.dynamic_usage_bounds()
139 }
140}
141
142impl Proof {
143 pub fn new(bytes: Vec<u8>) -> Self {
145 Proof(bytes)
146 }
147
148 pub const fn expected_proof_size(num_actions: usize) -> usize {
157 const BASE: usize = 2720;
161 const PER_ACTION: usize = 2272;
162 BASE + PER_ACTION * num_actions
163 }
164}
165
166#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
168pub enum ValuePool {
169 Orchard,
171 Ironwood,
173}
174
175#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
177pub enum ProtocolVersion {
178 InsecureV1,
185 V2,
191 V3,
203}