snarkvm_console_network/
lib.rs

1// Copyright 2024 Aleo Network Foundation
2// This file is part of the snarkVM library.
3
4// Licensed under the Apache License, Version 2.0 (the "License");
5// you may not use this file except in compliance with the License.
6// You may obtain a copy of the License at:
7
8// http://www.apache.org/licenses/LICENSE-2.0
9
10// Unless required by applicable law or agreed to in writing, software
11// distributed under the License is distributed on an "AS IS" BASIS,
12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13// See the License for the specific language governing permissions and
14// limitations under the License.
15
16#![forbid(unsafe_code)]
17#![allow(clippy::too_many_arguments)]
18#![warn(clippy::cast_possible_truncation)]
19
20#[macro_use]
21extern crate lazy_static;
22
23pub use snarkvm_console_network_environment as environment;
24pub use snarkvm_console_network_environment::*;
25
26mod helpers;
27pub use helpers::*;
28
29mod canary_v0;
30pub use canary_v0::*;
31
32mod mainnet_v0;
33pub use mainnet_v0::*;
34
35mod testnet_v0;
36pub use testnet_v0::*;
37
38pub mod prelude {
39    pub use crate::{ConsensusVersion, Network, consensus_config_value, environment::prelude::*};
40}
41
42use crate::environment::prelude::*;
43use snarkvm_algorithms::{
44    AlgebraicSponge,
45    crypto_hash::PoseidonSponge,
46    snark::varuna::{CircuitProvingKey, CircuitVerifyingKey, VarunaHidingMode},
47    srs::{UniversalProver, UniversalVerifier},
48};
49use snarkvm_console_algorithms::{BHP512, BHP1024, Poseidon2, Poseidon4};
50use snarkvm_console_collections::merkle_tree::{MerklePath, MerkleTree};
51use snarkvm_console_types::{Field, Group, Scalar};
52use snarkvm_curves::PairingEngine;
53
54use indexmap::IndexMap;
55use once_cell::sync::OnceCell;
56use std::sync::Arc;
57
58/// A helper type for the BHP Merkle tree.
59pub type BHPMerkleTree<N, const DEPTH: u8> = MerkleTree<N, BHP1024<N>, BHP512<N>, DEPTH>;
60/// A helper type for the Poseidon Merkle tree.
61pub type PoseidonMerkleTree<N, const DEPTH: u8> = MerkleTree<N, Poseidon4<N>, Poseidon2<N>, DEPTH>;
62
63/// Helper types for the Varuna parameters.
64type Fq<N> = <<N as Environment>::PairingCurve as PairingEngine>::Fq;
65pub type FiatShamir<N> = PoseidonSponge<Fq<N>, 2, 1>;
66pub type FiatShamirParameters<N> = <FiatShamir<N> as AlgebraicSponge<Fq<N>, 2>>::Parameters;
67
68/// Helper types for the Varuna proving and verifying key.
69pub(crate) type VarunaProvingKey<N> = CircuitProvingKey<<N as Environment>::PairingCurve, VarunaHidingMode>;
70pub(crate) type VarunaVerifyingKey<N> = CircuitVerifyingKey<<N as Environment>::PairingCurve>;
71
72/// The different consensus versions.
73/// Documentation for what is changed at each version can be found in `N::CONSENSUS_VERSION`
74#[derive(Debug, Copy, Clone, PartialEq, Eq, Ord, PartialOrd)]
75pub enum ConsensusVersion {
76    V1 = 1,
77    V2 = 2,
78    V3 = 3,
79}
80
81pub trait Network:
82    'static
83    + Environment
84    + Copy
85    + Clone
86    + Debug
87    + Eq
88    + PartialEq
89    + core::hash::Hash
90    + Serialize
91    + DeserializeOwned
92    + for<'a> Deserialize<'a>
93    + Send
94    + Sync
95{
96    /// The network ID.
97    const ID: u16;
98    /// The network name.
99    const NAME: &'static str;
100    /// The network edition.
101    const EDITION: u16;
102
103    /// The function name for the inclusion circuit.
104    const INCLUSION_FUNCTION_NAME: &'static str;
105
106    /// The fixed timestamp of the genesis block.
107    const GENESIS_TIMESTAMP: i64;
108    /// The genesis block coinbase target.
109    const GENESIS_COINBASE_TARGET: u64;
110    /// The genesis block proof target.
111    const GENESIS_PROOF_TARGET: u64;
112    /// The maximum number of solutions that can be included per block as a power of 2.
113    const MAX_SOLUTIONS_AS_POWER_OF_TWO: u8 = 2; // 4 solutions
114    /// The maximum number of solutions that can be included per block.
115    const MAX_SOLUTIONS: usize = 1 << Self::MAX_SOLUTIONS_AS_POWER_OF_TWO; // 4 solutions
116
117    /// The starting supply of Aleo credits.
118    const STARTING_SUPPLY: u64 = 1_500_000_000_000_000; // 1.5B credits
119    /// The cost in microcredits per byte for the deployment transaction.
120    const DEPLOYMENT_FEE_MULTIPLIER: u64 = 1_000; // 1 millicredit per byte
121    /// The constant that divides the storage polynomial.
122    const EXECUTION_STORAGE_FEE_SCALING_FACTOR: u64 = 5000;
123    /// The maximum size execution transactions can be before a quadratic storage penalty applies.
124    const EXECUTION_STORAGE_PENALTY_THRESHOLD: u64 = 5000;
125    /// The cost in microcredits per constraint for the deployment transaction.
126    const SYNTHESIS_FEE_MULTIPLIER: u64 = 25; // 25 microcredits per constraint
127    /// The maximum number of variables in a deployment.
128    const MAX_DEPLOYMENT_VARIABLES: u64 = 1 << 20; // 1,048,576 variables
129    /// The maximum number of constraints in a deployment.
130    const MAX_DEPLOYMENT_CONSTRAINTS: u64 = 1 << 20; // 1,048,576 constraints
131    /// The maximum number of microcredits that can be spent as a fee.
132    const MAX_FEE: u64 = 1_000_000_000_000_000;
133    /// The maximum number of microcredits that can be spent on a finalize block.
134    const TRANSACTION_SPEND_LIMIT: u64 = 100_000_000;
135
136    /// The anchor height, defined as the expected number of blocks to reach the coinbase target.
137    const ANCHOR_HEIGHT: u32 = Self::ANCHOR_TIME as u32 / Self::BLOCK_TIME as u32;
138    /// The anchor time in seconds.
139    const ANCHOR_TIME: u16 = 25;
140    /// The expected time per block in seconds.
141    const BLOCK_TIME: u16 = 10;
142    /// The number of blocks per epoch.
143    const NUM_BLOCKS_PER_EPOCH: u32 = 3600 / Self::BLOCK_TIME as u32; // 360 blocks == ~1 hour
144
145    /// The maximum number of entries in data.
146    const MAX_DATA_ENTRIES: usize = 32;
147    /// The maximum recursive depth of an entry.
148    /// Note: This value must be strictly less than u8::MAX.
149    const MAX_DATA_DEPTH: usize = 32;
150    /// The maximum number of fields in data (must not exceed u16::MAX).
151    #[allow(clippy::cast_possible_truncation)]
152    const MAX_DATA_SIZE_IN_FIELDS: u32 = ((128 * 1024 * 8) / Field::<Self>::SIZE_IN_DATA_BITS) as u32;
153
154    /// The minimum number of entries in a struct.
155    const MIN_STRUCT_ENTRIES: usize = 1; // This ensures the struct is not empty.
156    /// The maximum number of entries in a struct.
157    const MAX_STRUCT_ENTRIES: usize = Self::MAX_DATA_ENTRIES;
158
159    /// The minimum number of elements in an array.
160    const MIN_ARRAY_ELEMENTS: usize = 1; // This ensures the array is not empty.
161    /// The maximum number of elements in an array.
162    const MAX_ARRAY_ELEMENTS: usize = Self::MAX_DATA_ENTRIES;
163
164    /// The minimum number of entries in a record.
165    const MIN_RECORD_ENTRIES: usize = 1; // This accounts for 'record.owner'.
166    /// The maximum number of entries in a record.
167    const MAX_RECORD_ENTRIES: usize = Self::MIN_RECORD_ENTRIES.saturating_add(Self::MAX_DATA_ENTRIES);
168
169    /// The maximum program size by number of characters.
170    const MAX_PROGRAM_SIZE: usize = 100_000; // 100 KB
171
172    /// The maximum number of mappings in a program.
173    const MAX_MAPPINGS: usize = 31;
174    /// The maximum number of functions in a program.
175    const MAX_FUNCTIONS: usize = 31;
176    /// The maximum number of structs in a program.
177    const MAX_STRUCTS: usize = 10 * Self::MAX_FUNCTIONS;
178    /// The maximum number of records in a program.
179    const MAX_RECORDS: usize = 10 * Self::MAX_FUNCTIONS;
180    /// The maximum number of closures in a program.
181    const MAX_CLOSURES: usize = 2 * Self::MAX_FUNCTIONS;
182    /// The maximum number of operands in an instruction.
183    const MAX_OPERANDS: usize = Self::MAX_INPUTS;
184    /// The maximum number of instructions in a closure or function.
185    const MAX_INSTRUCTIONS: usize = u16::MAX as usize;
186    /// The maximum number of commands in finalize.
187    const MAX_COMMANDS: usize = u16::MAX as usize;
188    /// The maximum number of write commands in finalize.
189    const MAX_WRITES: u16 = 16;
190
191    /// The maximum number of inputs per transition.
192    const MAX_INPUTS: usize = 16;
193    /// The maximum number of outputs per transition.
194    const MAX_OUTPUTS: usize = 16;
195
196    /// The maximum program depth.
197    const MAX_PROGRAM_DEPTH: usize = 64;
198    /// The maximum number of imports.
199    const MAX_IMPORTS: usize = 64;
200
201    /// The maximum number of bytes in a transaction.
202    // Note: This value must **not** be decreased as it would invalidate existing transactions.
203    const MAX_TRANSACTION_SIZE: usize = 128_000; // 128 kB
204
205    /// The state root type.
206    type StateRoot: Bech32ID<Field<Self>>;
207    /// The block hash type.
208    type BlockHash: Bech32ID<Field<Self>>;
209    /// The ratification ID type.
210    type RatificationID: Bech32ID<Field<Self>>;
211    /// The transaction ID type.
212    type TransactionID: Bech32ID<Field<Self>>;
213    /// The transition ID type.
214    type TransitionID: Bech32ID<Field<Self>>;
215    /// The transmission checksum type.
216    type TransmissionChecksum: IntegerType;
217
218    /// A list of (consensus_version, block_height) pairs indicating when each consensus version takes effect.
219    /// Documentation for what is changed at each version can be found in `N::CONSENSUS_VERSION`
220    const CONSENSUS_VERSION_HEIGHTS: [(ConsensusVersion, u32); 3];
221    ///  A list of (consensus_version, size) pairs indicating the maximum number of validators in a committee.
222    //  Note: This value must **not** decrease without considering the impact on serialization.
223    //  Decreasing this value will break backwards compatibility of serialization without explicit
224    //  declaration of migration based on round number rather than block height.
225    //  Increasing this value will require a migration to prevent forking during network upgrades.
226    const MAX_CERTIFICATES: [(ConsensusVersion, u16); 2];
227
228    /// Returns the consensus version which is active at the given height.
229    ///
230    /// V1: The initial genesis consensus version.
231    ///
232    /// V2: Update to the block reward and execution cost algorithms.
233    ///
234    /// V3: Update to the number of validators and finalize scope RNG seed.
235    #[allow(non_snake_case)]
236    fn CONSENSUS_VERSION(seek_height: u32) -> anyhow::Result<ConsensusVersion> {
237        match Self::CONSENSUS_VERSION_HEIGHTS.binary_search_by(|(_, height)| height.cmp(&seek_height)) {
238            // If a consensus version was found at this height, return it.
239            Ok(index) => Ok(Self::CONSENSUS_VERSION_HEIGHTS[index].0),
240            // If the specified height was not found, determine whether to return an appropriate version.
241            Err(index) => {
242                if index == 0 {
243                    Err(anyhow!("Expected consensus version 1 to exist at height 0."))
244                } else {
245                    // Return the appropriate version belonging to the height *lower* than the sought height.
246                    Ok(Self::CONSENSUS_VERSION_HEIGHTS[index - 1].0)
247                }
248            }
249        }
250    }
251    /// Returns the height at which a specified consensus version becomes active.
252    #[allow(non_snake_case)]
253    fn CONSENSUS_HEIGHT(version: ConsensusVersion) -> Result<u32> {
254        Ok(Self::CONSENSUS_VERSION_HEIGHTS.get(version as usize - 1).ok_or(anyhow!("Invalid consensus version"))?.1)
255    }
256    /// Returns the last `MAX_CERTIFICATES` value.
257    #[allow(non_snake_case)]
258    fn LATEST_MAX_CERTIFICATES() -> Result<u16> {
259        Self::MAX_CERTIFICATES.last().map_or(Err(anyhow!("No MAX_CERTIFICATES defined.")), |(_, value)| Ok(*value))
260    }
261
262    /// Returns the genesis block bytes.
263    fn genesis_bytes() -> &'static [u8];
264
265    /// Returns the restrictions list as a JSON-compatible string.
266    fn restrictions_list_as_str() -> &'static str;
267
268    /// Returns the proving key for the given function name in `credits.aleo`.
269    fn get_credits_proving_key(function_name: String) -> Result<&'static Arc<VarunaProvingKey<Self>>>;
270
271    /// Returns the verifying key for the given function name in `credits.aleo`.
272    fn get_credits_verifying_key(function_name: String) -> Result<&'static Arc<VarunaVerifyingKey<Self>>>;
273
274    /// Returns the `proving key` for the inclusion circuit.
275    fn inclusion_proving_key() -> &'static Arc<VarunaProvingKey<Self>>;
276
277    /// Returns the `verifying key` for the inclusion circuit.
278    fn inclusion_verifying_key() -> &'static Arc<VarunaVerifyingKey<Self>>;
279
280    /// Returns the powers of `G`.
281    fn g_powers() -> &'static Vec<Group<Self>>;
282
283    /// Returns the scalar multiplication on the generator `G`.
284    fn g_scalar_multiply(scalar: &Scalar<Self>) -> Group<Self>;
285
286    /// Returns the Varuna universal prover.
287    fn varuna_universal_prover() -> &'static UniversalProver<Self::PairingCurve>;
288
289    /// Returns the Varuna universal verifier.
290    fn varuna_universal_verifier() -> &'static UniversalVerifier<Self::PairingCurve>;
291
292    /// Returns the sponge parameters for Varuna.
293    fn varuna_fs_parameters() -> &'static FiatShamirParameters<Self>;
294
295    /// Returns the encryption domain as a constant field element.
296    fn encryption_domain() -> Field<Self>;
297
298    /// Returns the graph key domain as a constant field element.
299    fn graph_key_domain() -> Field<Self>;
300
301    /// Returns the serial number domain as a constant field element.
302    fn serial_number_domain() -> Field<Self>;
303
304    /// Returns a BHP commitment with an input hasher of 256-bits and randomizer.
305    fn commit_bhp256(input: &[bool], randomizer: &Scalar<Self>) -> Result<Field<Self>>;
306
307    /// Returns a BHP commitment with an input hasher of 512-bits and randomizer.
308    fn commit_bhp512(input: &[bool], randomizer: &Scalar<Self>) -> Result<Field<Self>>;
309
310    /// Returns a BHP commitment with an input hasher of 768-bits and randomizer.
311    fn commit_bhp768(input: &[bool], randomizer: &Scalar<Self>) -> Result<Field<Self>>;
312
313    /// Returns a BHP commitment with an input hasher of 1024-bits and randomizer.
314    fn commit_bhp1024(input: &[bool], randomizer: &Scalar<Self>) -> Result<Field<Self>>;
315
316    /// Returns a Pedersen commitment for the given (up to) 64-bit input and randomizer.
317    fn commit_ped64(input: &[bool], randomizer: &Scalar<Self>) -> Result<Field<Self>>;
318
319    /// Returns a Pedersen commitment for the given (up to) 128-bit input and randomizer.
320    fn commit_ped128(input: &[bool], randomizer: &Scalar<Self>) -> Result<Field<Self>>;
321
322    /// Returns a BHP commitment with an input hasher of 256-bits and randomizer.
323    fn commit_to_group_bhp256(input: &[bool], randomizer: &Scalar<Self>) -> Result<Group<Self>>;
324
325    /// Returns a BHP commitment with an input hasher of 512-bits and randomizer.
326    fn commit_to_group_bhp512(input: &[bool], randomizer: &Scalar<Self>) -> Result<Group<Self>>;
327
328    /// Returns a BHP commitment with an input hasher of 768-bits and randomizer.
329    fn commit_to_group_bhp768(input: &[bool], randomizer: &Scalar<Self>) -> Result<Group<Self>>;
330
331    /// Returns a BHP commitment with an input hasher of 1024-bits and randomizer.
332    fn commit_to_group_bhp1024(input: &[bool], randomizer: &Scalar<Self>) -> Result<Group<Self>>;
333
334    /// Returns a Pedersen commitment for the given (up to) 64-bit input and randomizer.
335    fn commit_to_group_ped64(input: &[bool], randomizer: &Scalar<Self>) -> Result<Group<Self>>;
336
337    /// Returns a Pedersen commitment for the given (up to) 128-bit input and randomizer.
338    fn commit_to_group_ped128(input: &[bool], randomizer: &Scalar<Self>) -> Result<Group<Self>>;
339
340    /// Returns the BHP hash with an input hasher of 256-bits.
341    fn hash_bhp256(input: &[bool]) -> Result<Field<Self>>;
342
343    /// Returns the BHP hash with an input hasher of 512-bits.
344    fn hash_bhp512(input: &[bool]) -> Result<Field<Self>>;
345
346    /// Returns the BHP hash with an input hasher of 768-bits.
347    fn hash_bhp768(input: &[bool]) -> Result<Field<Self>>;
348
349    /// Returns the BHP hash with an input hasher of 1024-bits.
350    fn hash_bhp1024(input: &[bool]) -> Result<Field<Self>>;
351
352    /// Returns the Keccak hash with a 256-bit output.
353    fn hash_keccak256(input: &[bool]) -> Result<Vec<bool>>;
354
355    /// Returns the Keccak hash with a 384-bit output.
356    fn hash_keccak384(input: &[bool]) -> Result<Vec<bool>>;
357
358    /// Returns the Keccak hash with a 512-bit output.
359    fn hash_keccak512(input: &[bool]) -> Result<Vec<bool>>;
360
361    /// Returns the Pedersen hash for a given (up to) 64-bit input.
362    fn hash_ped64(input: &[bool]) -> Result<Field<Self>>;
363
364    /// Returns the Pedersen hash for a given (up to) 128-bit input.
365    fn hash_ped128(input: &[bool]) -> Result<Field<Self>>;
366
367    /// Returns the Poseidon hash with an input rate of 2.
368    fn hash_psd2(input: &[Field<Self>]) -> Result<Field<Self>>;
369
370    /// Returns the Poseidon hash with an input rate of 4.
371    fn hash_psd4(input: &[Field<Self>]) -> Result<Field<Self>>;
372
373    /// Returns the Poseidon hash with an input rate of 8.
374    fn hash_psd8(input: &[Field<Self>]) -> Result<Field<Self>>;
375
376    /// Returns the SHA-3 hash with a 256-bit output.
377    fn hash_sha3_256(input: &[bool]) -> Result<Vec<bool>>;
378
379    /// Returns the SHA-3 hash with a 384-bit output.
380    fn hash_sha3_384(input: &[bool]) -> Result<Vec<bool>>;
381
382    /// Returns the SHA-3 hash with a 512-bit output.
383    fn hash_sha3_512(input: &[bool]) -> Result<Vec<bool>>;
384
385    /// Returns the extended Poseidon hash with an input rate of 2.
386    fn hash_many_psd2(input: &[Field<Self>], num_outputs: u16) -> Vec<Field<Self>>;
387
388    /// Returns the extended Poseidon hash with an input rate of 4.
389    fn hash_many_psd4(input: &[Field<Self>], num_outputs: u16) -> Vec<Field<Self>>;
390
391    /// Returns the extended Poseidon hash with an input rate of 8.
392    fn hash_many_psd8(input: &[Field<Self>], num_outputs: u16) -> Vec<Field<Self>>;
393
394    /// Returns the BHP hash with an input hasher of 256-bits.
395    fn hash_to_group_bhp256(input: &[bool]) -> Result<Group<Self>>;
396
397    /// Returns the BHP hash with an input hasher of 512-bits.
398    fn hash_to_group_bhp512(input: &[bool]) -> Result<Group<Self>>;
399
400    /// Returns the BHP hash with an input hasher of 768-bits.
401    fn hash_to_group_bhp768(input: &[bool]) -> Result<Group<Self>>;
402
403    /// Returns the BHP hash with an input hasher of 1024-bits.
404    fn hash_to_group_bhp1024(input: &[bool]) -> Result<Group<Self>>;
405
406    /// Returns the Pedersen hash for a given (up to) 64-bit input.
407    fn hash_to_group_ped64(input: &[bool]) -> Result<Group<Self>>;
408
409    /// Returns the Pedersen hash for a given (up to) 128-bit input.
410    fn hash_to_group_ped128(input: &[bool]) -> Result<Group<Self>>;
411
412    /// Returns the Poseidon hash with an input rate of 2 on the affine curve.
413    fn hash_to_group_psd2(input: &[Field<Self>]) -> Result<Group<Self>>;
414
415    /// Returns the Poseidon hash with an input rate of 4 on the affine curve.
416    fn hash_to_group_psd4(input: &[Field<Self>]) -> Result<Group<Self>>;
417
418    /// Returns the Poseidon hash with an input rate of 8 on the affine curve.
419    fn hash_to_group_psd8(input: &[Field<Self>]) -> Result<Group<Self>>;
420
421    /// Returns the Poseidon hash with an input rate of 2 on the scalar field.
422    fn hash_to_scalar_psd2(input: &[Field<Self>]) -> Result<Scalar<Self>>;
423
424    /// Returns the Poseidon hash with an input rate of 4 on the scalar field.
425    fn hash_to_scalar_psd4(input: &[Field<Self>]) -> Result<Scalar<Self>>;
426
427    /// Returns the Poseidon hash with an input rate of 8 on the scalar field.
428    fn hash_to_scalar_psd8(input: &[Field<Self>]) -> Result<Scalar<Self>>;
429
430    /// Returns a Merkle tree with a BHP leaf hasher of 1024-bits and a BHP path hasher of 512-bits.
431    fn merkle_tree_bhp<const DEPTH: u8>(leaves: &[Vec<bool>]) -> Result<BHPMerkleTree<Self, DEPTH>>;
432
433    /// Returns a Merkle tree with a Poseidon leaf hasher with input rate of 4 and a Poseidon path hasher with input rate of 2.
434    fn merkle_tree_psd<const DEPTH: u8>(leaves: &[Vec<Field<Self>>]) -> Result<PoseidonMerkleTree<Self, DEPTH>>;
435
436    /// Returns `true` if the given Merkle path is valid for the given root and leaf.
437    #[allow(clippy::ptr_arg)]
438    fn verify_merkle_path_bhp<const DEPTH: u8>(
439        path: &MerklePath<Self, DEPTH>,
440        root: &Field<Self>,
441        leaf: &Vec<bool>,
442    ) -> bool;
443
444    /// Returns `true` if the given Merkle path is valid for the given root and leaf.
445    #[allow(clippy::ptr_arg)]
446    fn verify_merkle_path_psd<const DEPTH: u8>(
447        path: &MerklePath<Self, DEPTH>,
448        root: &Field<Self>,
449        leaf: &Vec<Field<Self>>,
450    ) -> bool;
451}
452
453/// Returns the consensus configuration value for the specified height.
454///
455/// Arguments:
456/// - `$network`: The network to use the constant of.
457/// - `$constant`: The constant to search a value of.
458/// - `$seek_height`: The block height to search the value for.
459#[macro_export]
460macro_rules! consensus_config_value {
461    ($network:ident, $constant:ident, $seek_height:expr) => {
462        // Search the consensus version enacted at the specified height.
463        $network::CONSENSUS_VERSION($seek_height).map_or(None, |seek_version| {
464            // Search the consensus value for the specified version.
465            match $network::$constant.binary_search_by(|(version, _)| version.cmp(&seek_version)) {
466                // If a value was found for this consensus version, return it.
467                Ok(index) => Some($network::$constant[index].1),
468                // If the specified version was not found exactly, determine whether to return an appropriate value anyway.
469                Err(index) => {
470                    // This constant is not yet in effect at this consensus version.
471                    if index == 0 {
472                        None
473                    // Return the appropriate value belonging to the consensus version *lower* than the sought version.
474                    } else {
475                        Some($network::$constant[index - 1].1)
476                    }
477                }
478            }
479        })
480    };
481}
482
483#[cfg(test)]
484mod tests {
485    use super::*;
486
487    /// Ensure that the consensus constants are defined and correct at genesis.
488    /// It is possible this invariant no longer holds in the future, e.g. due to pruning or novel types of constants.
489    fn consensus_constants_at_genesis<N: Network>() {
490        let height = N::CONSENSUS_VERSION_HEIGHTS.first().unwrap().1;
491        assert_eq!(height, 0);
492        let consensus_version = N::CONSENSUS_VERSION_HEIGHTS.first().unwrap().0;
493        assert_eq!(consensus_version, ConsensusVersion::V1);
494        assert_eq!(consensus_version as usize, 1);
495    }
496
497    /// Ensure that the consensus *versions* are unique, incrementing and start with 1.
498    fn consensus_versions<N: Network>() {
499        let mut previous_version = N::CONSENSUS_VERSION_HEIGHTS.first().unwrap().0;
500        // Ensure that the consensus versions start with 1.
501        assert_eq!(previous_version as usize, 1);
502        // Ensure that the consensus versions are unique and incrementing by 1.
503        for (version, _) in N::CONSENSUS_VERSION_HEIGHTS.iter().skip(1) {
504            assert_eq!(*version as usize, previous_version as usize + 1);
505            previous_version = *version;
506        }
507        // Ensure that the consensus versions are unique and incrementing.
508        let mut previous_version = N::MAX_CERTIFICATES.first().unwrap().0;
509        for (version, _) in N::MAX_CERTIFICATES.iter().skip(1) {
510            assert!(*version > previous_version);
511            previous_version = *version;
512        }
513    }
514
515    /// Ensure that consensus *heights* are unique and incrementing.
516    fn consensus_constants_increasing_heights<N: Network>() {
517        let mut previous_height = N::CONSENSUS_VERSION_HEIGHTS.first().unwrap().1;
518        for (version, height) in N::CONSENSUS_VERSION_HEIGHTS.iter().skip(1) {
519            assert!(*height > previous_height);
520            previous_height = *height;
521            // Ensure that N::CONSENSUS_VERSION returns the expected value.
522            assert_eq!(N::CONSENSUS_VERSION(*height).unwrap(), *version);
523            // Ensure that N::CONSENSUS_HEIGHT returns the expected value.
524            assert_eq!(N::CONSENSUS_HEIGHT(*version).unwrap(), *height);
525        }
526    }
527
528    /// Ensure that version of all consensus-relevant constants are present in the consensus version heights.
529    fn consensus_constants_valid_heights<N: Network>() {
530        for (version, value) in N::MAX_CERTIFICATES.iter() {
531            // Ensure that the height at which an update occurs are present in CONSENSUS_VERSION_HEIGHTS.
532            let height = N::CONSENSUS_VERSION_HEIGHTS.iter().find(|(c_version, _)| *c_version == *version).unwrap().1;
533            // Double-check that consensus_config_value returns the correct value.
534            assert_eq!(consensus_config_value!(N, MAX_CERTIFICATES, height).unwrap(), *value);
535        }
536    }
537
538    /// Ensure that `MAX_CERTIFICATES` increases and is correctly defined.
539    /// See the constant declaration for an explanation why.
540    fn max_certificates_increasing<N: Network>() {
541        let mut previous_value = N::MAX_CERTIFICATES.first().unwrap().1;
542        for (_, value) in N::MAX_CERTIFICATES.iter().skip(1) {
543            assert!(*value >= previous_value);
544            previous_value = *value;
545        }
546    }
547
548    /// Ensure that the number of constant definitions is the same across networks.
549    fn constants_equal_length<N1: Network, N2: Network, N3: Network>() {
550        // If we can construct an array, that means the underlying types must be the same.
551        let _ = [N1::CONSENSUS_VERSION_HEIGHTS, N2::CONSENSUS_VERSION_HEIGHTS, N3::CONSENSUS_VERSION_HEIGHTS];
552        let _ = [N1::MAX_CERTIFICATES, N2::MAX_CERTIFICATES, N3::MAX_CERTIFICATES];
553    }
554
555    #[test]
556    #[allow(clippy::assertions_on_constants)]
557    fn test_consensus_constants() {
558        consensus_constants_at_genesis::<MainnetV0>();
559        consensus_constants_at_genesis::<TestnetV0>();
560        consensus_constants_at_genesis::<CanaryV0>();
561
562        consensus_versions::<MainnetV0>();
563        consensus_versions::<TestnetV0>();
564        consensus_versions::<CanaryV0>();
565
566        consensus_constants_increasing_heights::<MainnetV0>();
567        consensus_constants_increasing_heights::<TestnetV0>();
568        consensus_constants_increasing_heights::<CanaryV0>();
569
570        consensus_constants_valid_heights::<MainnetV0>();
571        consensus_constants_valid_heights::<TestnetV0>();
572        consensus_constants_valid_heights::<CanaryV0>();
573
574        max_certificates_increasing::<MainnetV0>();
575        max_certificates_increasing::<TestnetV0>();
576        max_certificates_increasing::<CanaryV0>();
577
578        constants_equal_length::<MainnetV0, TestnetV0, CanaryV0>();
579    }
580}
snarkvm_console_network/lib.rs

snarkvm_console_network/
lib.rs
