snarkvm_console_network/
mainnet_v0.rs

1// Copyright 2024-2025 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
16use super::*;
17use snarkvm_console_algorithms::{
18    BHP256,
19    BHP512,
20    BHP768,
21    BHP1024,
22    Blake2Xs,
23    Keccak256,
24    Keccak384,
25    Keccak512,
26    Pedersen64,
27    Pedersen128,
28    Poseidon2,
29    Poseidon4,
30    Poseidon8,
31    Sha3_256,
32    Sha3_384,
33    Sha3_512,
34};
35
36lazy_static! {
37    /// The group bases for the Aleo signature and encryption schemes.
38    pub static ref GENERATOR_G: Vec<Group<MainnetV0 >> = MainnetV0::new_bases("AleoAccountEncryptionAndSignatureScheme0");
39
40    /// The Varuna sponge parameters.
41    pub static ref VARUNA_FS_PARAMETERS: FiatShamirParameters<MainnetV0> = FiatShamir::<MainnetV0>::sample_parameters();
42
43    /// The encryption domain as a constant field element.
44    pub static ref ENCRYPTION_DOMAIN: Field<MainnetV0> = Field::<MainnetV0>::new_domain_separator("AleoSymmetricEncryption0");
45    /// The graph key domain as a constant field element.
46    pub static ref GRAPH_KEY_DOMAIN: Field<MainnetV0> = Field::<MainnetV0>::new_domain_separator("AleoGraphKey0");
47    /// The serial number domain as a constant field element.
48    pub static ref SERIAL_NUMBER_DOMAIN: Field<MainnetV0> = Field::<MainnetV0>::new_domain_separator("AleoSerialNumber0");
49
50    /// The BHP hash function, which can take an input of up to 256 bits.
51    pub static ref BHP_256: BHP256<MainnetV0> = BHP256::<MainnetV0>::setup("AleoBHP256").expect("Failed to setup BHP256");
52    /// The BHP hash function, which can take an input of up to 512 bits.
53    pub static ref BHP_512: BHP512<MainnetV0> = BHP512::<MainnetV0>::setup("AleoBHP512").expect("Failed to setup BHP512");
54    /// The BHP hash function, which can take an input of up to 768 bits.
55    pub static ref BHP_768: BHP768<MainnetV0> = BHP768::<MainnetV0>::setup("AleoBHP768").expect("Failed to setup BHP768");
56    /// The BHP hash function, which can take an input of up to 1024 bits.
57    pub static ref BHP_1024: BHP1024<MainnetV0> = BHP1024::<MainnetV0>::setup("AleoBHP1024").expect("Failed to setup BHP1024");
58
59    /// The Pedersen hash function, which can take an input of up to 64 bits.
60    pub static ref PEDERSEN_64: Pedersen64<MainnetV0> = Pedersen64::<MainnetV0>::setup("AleoPedersen64");
61    /// The Pedersen hash function, which can take an input of up to 128 bits.
62    pub static ref PEDERSEN_128: Pedersen128<MainnetV0> = Pedersen128::<MainnetV0>::setup("AleoPedersen128");
63
64    /// The Poseidon hash function, using a rate of 2.
65    pub static ref POSEIDON_2: Poseidon2<MainnetV0> = Poseidon2::<MainnetV0>::setup("AleoPoseidon2").expect("Failed to setup Poseidon2");
66    /// The Poseidon hash function, using a rate of 4.
67    pub static ref POSEIDON_4: Poseidon4<MainnetV0> = Poseidon4::<MainnetV0>::setup("AleoPoseidon4").expect("Failed to setup Poseidon4");
68    /// The Poseidon hash function, using a rate of 8.
69    pub static ref POSEIDON_8: Poseidon8<MainnetV0> = Poseidon8::<MainnetV0>::setup("AleoPoseidon8").expect("Failed to setup Poseidon8");
70
71    pub static ref CREDITS_PROVING_KEYS: IndexMap<String, Arc<VarunaProvingKey<Console>>> = {
72        let mut map = IndexMap::new();
73        snarkvm_parameters::insert_credit_keys!(map, VarunaProvingKey<Console>, Prover);
74        map
75    };
76    pub static ref CREDITS_VERIFYING_KEYS: IndexMap<String, Arc<VarunaVerifyingKey<Console>>> = {
77        let mut map = IndexMap::new();
78        snarkvm_parameters::insert_credit_keys!(map, VarunaVerifyingKey<Console>, Verifier);
79        map
80    };
81}
82
83pub const TRANSACTION_PREFIX: &str = "at";
84
85#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
86pub struct MainnetV0;
87
88impl MainnetV0 {
89    /// Initializes a new instance of group bases from a given input domain message.
90    fn new_bases(message: &str) -> Vec<Group<Self>> {
91        // Hash the given message to a point on the curve, to initialize the starting base.
92        let (base, _, _) = Blake2Xs::hash_to_curve::<<Self as Environment>::Affine>(message);
93
94        // Compute the bases up to the size of the scalar field (in bits).
95        let mut g = Group::<Self>::new(base);
96        let mut g_bases = Vec::with_capacity(Scalar::<Self>::size_in_bits());
97        for _ in 0..Scalar::<Self>::size_in_bits() {
98            g_bases.push(g);
99            g = g.double();
100        }
101        g_bases
102    }
103}
104
105impl Environment for MainnetV0 {
106    type Affine = <Console as Environment>::Affine;
107    type BigInteger = <Console as Environment>::BigInteger;
108    type Field = <Console as Environment>::Field;
109    type PairingCurve = <Console as Environment>::PairingCurve;
110    type Projective = <Console as Environment>::Projective;
111    type Scalar = <Console as Environment>::Scalar;
112
113    /// The coefficient `A` of the twisted Edwards curve.
114    const EDWARDS_A: Self::Field = Console::EDWARDS_A;
115    /// The coefficient `D` of the twisted Edwards curve.
116    const EDWARDS_D: Self::Field = Console::EDWARDS_D;
117    /// The coefficient `A` of the Montgomery curve.
118    const MONTGOMERY_A: Self::Field = Console::MONTGOMERY_A;
119    /// The coefficient `B` of the Montgomery curve.
120    const MONTGOMERY_B: Self::Field = Console::MONTGOMERY_B;
121}
122
123impl Network for MainnetV0 {
124    /// The block hash type.
125    type BlockHash = AleoID<Field<Self>, { hrp2!("ab") }>;
126    /// The ratification ID type.
127    type RatificationID = AleoID<Field<Self>, { hrp2!("ar") }>;
128    /// The state root type.
129    type StateRoot = AleoID<Field<Self>, { hrp2!("sr") }>;
130    /// The transaction ID type.
131    type TransactionID = AleoID<Field<Self>, { hrp2!(TRANSACTION_PREFIX) }>;
132    /// The transition ID type.
133    type TransitionID = AleoID<Field<Self>, { hrp2!("au") }>;
134    /// The transmission checksum type.
135    type TransmissionChecksum = u128;
136
137    /// A list of (consensus_version, block_height) pairs indicating when each consensus version takes effect.
138    /// Documentation for what is changed at each version can be found in `N::CONSENSUS_VERSION`
139    #[cfg(not(any(test, feature = "test")))]
140    const CONSENSUS_VERSION_HEIGHTS: [(ConsensusVersion, u32); 5] = [
141        (ConsensusVersion::V1, 0),
142        (ConsensusVersion::V2, 2_800_000),
143        (ConsensusVersion::V3, 4_900_000),
144        (ConsensusVersion::V4, 6_135_000),
145        (ConsensusVersion::V5, 7_060_000),
146    ];
147    /// A list of (consensus_version, block_height) pairs indicating when each consensus version takes effect.
148    /// Documentation for what is changed at each version can be found in `N::CONSENSUS_VERSION`
149    #[cfg(any(test, feature = "test"))]
150    const CONSENSUS_VERSION_HEIGHTS: [(ConsensusVersion, u32); 5] = [
151        (ConsensusVersion::V1, 0),
152        (ConsensusVersion::V2, 10),
153        (ConsensusVersion::V3, 11),
154        (ConsensusVersion::V4, 12),
155        (ConsensusVersion::V5, 13),
156    ];
157    /// The network edition.
158    const EDITION: u16 = 0;
159    /// The genesis block coinbase target.
160    #[cfg(not(feature = "test"))]
161    const GENESIS_COINBASE_TARGET: u64 = (1u64 << 29).saturating_sub(1);
162    /// The genesis block coinbase target.
163    /// This is deliberately set to a low value (32) for testing purposes only.
164    #[cfg(feature = "test")]
165    const GENESIS_COINBASE_TARGET: u64 = (1u64 << 5).saturating_sub(1);
166    /// The genesis block proof target.
167    #[cfg(not(feature = "test"))]
168    const GENESIS_PROOF_TARGET: u64 = 1u64 << 27;
169    /// The genesis block proof target.
170    /// This is deliberately set to a low value (8) for testing purposes only.
171    #[cfg(feature = "test")]
172    const GENESIS_PROOF_TARGET: u64 = 1u64 << 3;
173    /// The fixed timestamp of the genesis block.
174    const GENESIS_TIMESTAMP: i64 = 1725462000 /* 2024-09-04 11:00:00 UTC */;
175    /// The network ID.
176    const ID: u16 = 0;
177    /// The function name for the inclusion circuit.
178    const INCLUSION_FUNCTION_NAME: &'static str = snarkvm_parameters::mainnet::NETWORK_INCLUSION_FUNCTION_NAME;
179    /// A list of (consensus_version, size) pairs indicating the maximum number of certificates in a batch.
180    #[cfg(not(any(test, feature = "test")))]
181    const MAX_CERTIFICATES: [(ConsensusVersion, u16); 3] =
182        [(ConsensusVersion::V1, 16), (ConsensusVersion::V3, 25), (ConsensusVersion::V5, 30)];
183    /// A list of (consensus_version, size) pairs indicating the maximum number of certificates in a batch.
184    #[cfg(any(test, feature = "test"))]
185    const MAX_CERTIFICATES: [(ConsensusVersion, u16); 3] =
186        [(ConsensusVersion::V1, 100), (ConsensusVersion::V3, 100), (ConsensusVersion::V5, 100)];
187    /// The network name.
188    const NAME: &'static str = "Aleo Mainnet (v0)";
189
190    /// Returns the genesis block bytes.
191    fn genesis_bytes() -> &'static [u8] {
192        snarkvm_parameters::mainnet::GenesisBytes::load_bytes()
193    }
194
195    /// Returns the restrictions list as a JSON-compatible string.
196    fn restrictions_list_as_str() -> &'static str {
197        snarkvm_parameters::mainnet::RESTRICTIONS_LIST
198    }
199
200    /// Returns the proving key for the given function name in `credits.aleo`.
201    fn get_credits_proving_key(function_name: String) -> Result<&'static Arc<VarunaProvingKey<Self>>> {
202        CREDITS_PROVING_KEYS
203            .get(&function_name)
204            .ok_or_else(|| anyhow!("Proving key for credits.aleo/{function_name}' not found"))
205    }
206
207    /// Returns the verifying key for the given function name in `credits.aleo`.
208    fn get_credits_verifying_key(function_name: String) -> Result<&'static Arc<VarunaVerifyingKey<Self>>> {
209        CREDITS_VERIFYING_KEYS
210            .get(&function_name)
211            .ok_or_else(|| anyhow!("Verifying key for credits.aleo/{function_name}' not found"))
212    }
213
214    /// Returns the `proving key` for the inclusion circuit.
215    fn inclusion_proving_key() -> &'static Arc<VarunaProvingKey<Self>> {
216        static INSTANCE: OnceCell<Arc<VarunaProvingKey<Console>>> = OnceCell::new();
217        INSTANCE.get_or_init(|| {
218            // Skipping the first byte, which is the encoded version.
219            Arc::new(
220                CircuitProvingKey::from_bytes_le(&snarkvm_parameters::mainnet::INCLUSION_PROVING_KEY[1..])
221                    .expect("Failed to load inclusion proving key."),
222            )
223        })
224    }
225
226    /// Returns the `verifying key` for the inclusion circuit.
227    fn inclusion_verifying_key() -> &'static Arc<VarunaVerifyingKey<Self>> {
228        static INSTANCE: OnceCell<Arc<VarunaVerifyingKey<Console>>> = OnceCell::new();
229        INSTANCE.get_or_init(|| {
230            // Skipping the first byte, which is the encoded version.
231            Arc::new(
232                CircuitVerifyingKey::from_bytes_le(&snarkvm_parameters::mainnet::INCLUSION_VERIFYING_KEY[1..])
233                    .expect("Failed to load inclusion verifying key."),
234            )
235        })
236    }
237
238    /// Returns the powers of `G`.
239    fn g_powers() -> &'static Vec<Group<Self>> {
240        &GENERATOR_G
241    }
242
243    /// Returns the scalar multiplication on the generator `G`.
244    fn g_scalar_multiply(scalar: &Scalar<Self>) -> Group<Self> {
245        GENERATOR_G
246            .iter()
247            .zip_eq(&scalar.to_bits_le())
248            .filter_map(|(base, bit)| match bit {
249                true => Some(base),
250                false => None,
251            })
252            .sum()
253    }
254
255    /// Returns the Varuna universal prover.
256    fn varuna_universal_prover() -> &'static UniversalProver<Self::PairingCurve> {
257        static INSTANCE: OnceCell<UniversalProver<<Console as Environment>::PairingCurve>> = OnceCell::new();
258        INSTANCE.get_or_init(|| {
259            snarkvm_algorithms::polycommit::kzg10::UniversalParams::load()
260                .expect("Failed to load universal SRS (KZG10).")
261                .to_universal_prover()
262                .expect("Failed to convert universal SRS (KZG10) to the prover.")
263        })
264    }
265
266    /// Returns the Varuna universal verifier.
267    fn varuna_universal_verifier() -> &'static UniversalVerifier<Self::PairingCurve> {
268        static INSTANCE: OnceCell<UniversalVerifier<<Console as Environment>::PairingCurve>> = OnceCell::new();
269        INSTANCE.get_or_init(|| {
270            snarkvm_algorithms::polycommit::kzg10::UniversalParams::load()
271                .expect("Failed to load universal SRS (KZG10).")
272                .to_universal_verifier()
273                .expect("Failed to convert universal SRS (KZG10) to the verifier.")
274        })
275    }
276
277    /// Returns the sponge parameters used for the sponge in the Varuna SNARK.
278    fn varuna_fs_parameters() -> &'static FiatShamirParameters<Self> {
279        &VARUNA_FS_PARAMETERS
280    }
281
282    /// Returns the encryption domain as a constant field element.
283    fn encryption_domain() -> Field<Self> {
284        *ENCRYPTION_DOMAIN
285    }
286
287    /// Returns the graph key domain as a constant field element.
288    fn graph_key_domain() -> Field<Self> {
289        *GRAPH_KEY_DOMAIN
290    }
291
292    /// Returns the serial number domain as a constant field element.
293    fn serial_number_domain() -> Field<Self> {
294        *SERIAL_NUMBER_DOMAIN
295    }
296
297    /// Returns a BHP commitment with an input hasher of 256-bits and randomizer.
298    fn commit_bhp256(input: &[bool], randomizer: &Scalar<Self>) -> Result<Field<Self>> {
299        BHP_256.commit(input, randomizer)
300    }
301
302    /// Returns a BHP commitment with an input hasher of 512-bits and randomizer.
303    fn commit_bhp512(input: &[bool], randomizer: &Scalar<Self>) -> Result<Field<Self>> {
304        BHP_512.commit(input, randomizer)
305    }
306
307    /// Returns a BHP commitment with an input hasher of 768-bits and randomizer.
308    fn commit_bhp768(input: &[bool], randomizer: &Scalar<Self>) -> Result<Field<Self>> {
309        BHP_768.commit(input, randomizer)
310    }
311
312    /// Returns a BHP commitment with an input hasher of 1024-bits and randomizer.
313    fn commit_bhp1024(input: &[bool], randomizer: &Scalar<Self>) -> Result<Field<Self>> {
314        BHP_1024.commit(input, randomizer)
315    }
316
317    /// Returns a Pedersen commitment for the given (up to) 64-bit input and randomizer.
318    fn commit_ped64(input: &[bool], randomizer: &Scalar<Self>) -> Result<Field<Self>> {
319        PEDERSEN_64.commit(input, randomizer)
320    }
321
322    /// Returns a Pedersen commitment for the given (up to) 128-bit input and randomizer.
323    fn commit_ped128(input: &[bool], randomizer: &Scalar<Self>) -> Result<Field<Self>> {
324        PEDERSEN_128.commit(input, randomizer)
325    }
326
327    /// Returns a BHP commitment with an input hasher of 256-bits and randomizer.
328    fn commit_to_group_bhp256(input: &[bool], randomizer: &Scalar<Self>) -> Result<Group<Self>> {
329        BHP_256.commit_uncompressed(input, randomizer)
330    }
331
332    /// Returns a BHP commitment with an input hasher of 512-bits and randomizer.
333    fn commit_to_group_bhp512(input: &[bool], randomizer: &Scalar<Self>) -> Result<Group<Self>> {
334        BHP_512.commit_uncompressed(input, randomizer)
335    }
336
337    /// Returns a BHP commitment with an input hasher of 768-bits and randomizer.
338    fn commit_to_group_bhp768(input: &[bool], randomizer: &Scalar<Self>) -> Result<Group<Self>> {
339        BHP_768.commit_uncompressed(input, randomizer)
340    }
341
342    /// Returns a BHP commitment with an input hasher of 1024-bits and randomizer.
343    fn commit_to_group_bhp1024(input: &[bool], randomizer: &Scalar<Self>) -> Result<Group<Self>> {
344        BHP_1024.commit_uncompressed(input, randomizer)
345    }
346
347    /// Returns a Pedersen commitment for the given (up to) 64-bit input and randomizer.
348    fn commit_to_group_ped64(input: &[bool], randomizer: &Scalar<Self>) -> Result<Group<Self>> {
349        PEDERSEN_64.commit_uncompressed(input, randomizer)
350    }
351
352    /// Returns a Pedersen commitment for the given (up to) 128-bit input and randomizer.
353    fn commit_to_group_ped128(input: &[bool], randomizer: &Scalar<Self>) -> Result<Group<Self>> {
354        PEDERSEN_128.commit_uncompressed(input, randomizer)
355    }
356
357    /// Returns the BHP hash with an input hasher of 256-bits.
358    fn hash_bhp256(input: &[bool]) -> Result<Field<Self>> {
359        BHP_256.hash(input)
360    }
361
362    /// Returns the BHP hash with an input hasher of 512-bits.
363    fn hash_bhp512(input: &[bool]) -> Result<Field<Self>> {
364        BHP_512.hash(input)
365    }
366
367    /// Returns the BHP hash with an input hasher of 768-bits.
368    fn hash_bhp768(input: &[bool]) -> Result<Field<Self>> {
369        BHP_768.hash(input)
370    }
371
372    /// Returns the BHP hash with an input hasher of 1024-bits.
373    fn hash_bhp1024(input: &[bool]) -> Result<Field<Self>> {
374        BHP_1024.hash(input)
375    }
376
377    /// Returns the Keccak hash with a 256-bit output.
378    fn hash_keccak256(input: &[bool]) -> Result<Vec<bool>> {
379        Keccak256::default().hash(input)
380    }
381
382    /// Returns the Keccak hash with a 384-bit output.
383    fn hash_keccak384(input: &[bool]) -> Result<Vec<bool>> {
384        Keccak384::default().hash(input)
385    }
386
387    /// Returns the Keccak hash with a 512-bit output.
388    fn hash_keccak512(input: &[bool]) -> Result<Vec<bool>> {
389        Keccak512::default().hash(input)
390    }
391
392    /// Returns the Pedersen hash for a given (up to) 64-bit input.
393    fn hash_ped64(input: &[bool]) -> Result<Field<Self>> {
394        PEDERSEN_64.hash(input)
395    }
396
397    /// Returns the Pedersen hash for a given (up to) 128-bit input.
398    fn hash_ped128(input: &[bool]) -> Result<Field<Self>> {
399        PEDERSEN_128.hash(input)
400    }
401
402    /// Returns the Poseidon hash with an input rate of 2.
403    fn hash_psd2(input: &[Field<Self>]) -> Result<Field<Self>> {
404        POSEIDON_2.hash(input)
405    }
406
407    /// Returns the Poseidon hash with an input rate of 4.
408    fn hash_psd4(input: &[Field<Self>]) -> Result<Field<Self>> {
409        POSEIDON_4.hash(input)
410    }
411
412    /// Returns the Poseidon hash with an input rate of 8.
413    fn hash_psd8(input: &[Field<Self>]) -> Result<Field<Self>> {
414        POSEIDON_8.hash(input)
415    }
416
417    /// Returns the SHA-3 hash with a 256-bit output.
418    fn hash_sha3_256(input: &[bool]) -> Result<Vec<bool>> {
419        Sha3_256::default().hash(input)
420    }
421
422    /// Returns the SHA-3 hash with a 384-bit output.
423    fn hash_sha3_384(input: &[bool]) -> Result<Vec<bool>> {
424        Sha3_384::default().hash(input)
425    }
426
427    /// Returns the SHA-3 hash with a 512-bit output.
428    fn hash_sha3_512(input: &[bool]) -> Result<Vec<bool>> {
429        Sha3_512::default().hash(input)
430    }
431
432    /// Returns the extended Poseidon hash with an input rate of 2.
433    fn hash_many_psd2(input: &[Field<Self>], num_outputs: u16) -> Vec<Field<Self>> {
434        POSEIDON_2.hash_many(input, num_outputs)
435    }
436
437    /// Returns the extended Poseidon hash with an input rate of 4.
438    fn hash_many_psd4(input: &[Field<Self>], num_outputs: u16) -> Vec<Field<Self>> {
439        POSEIDON_4.hash_many(input, num_outputs)
440    }
441
442    /// Returns the extended Poseidon hash with an input rate of 8.
443    fn hash_many_psd8(input: &[Field<Self>], num_outputs: u16) -> Vec<Field<Self>> {
444        POSEIDON_8.hash_many(input, num_outputs)
445    }
446
447    /// Returns the BHP hash with an input hasher of 256-bits.
448    fn hash_to_group_bhp256(input: &[bool]) -> Result<Group<Self>> {
449        BHP_256.hash_uncompressed(input)
450    }
451
452    /// Returns the BHP hash with an input hasher of 512-bits.
453    fn hash_to_group_bhp512(input: &[bool]) -> Result<Group<Self>> {
454        BHP_512.hash_uncompressed(input)
455    }
456
457    /// Returns the BHP hash with an input hasher of 768-bits.
458    fn hash_to_group_bhp768(input: &[bool]) -> Result<Group<Self>> {
459        BHP_768.hash_uncompressed(input)
460    }
461
462    /// Returns the BHP hash with an input hasher of 1024-bits.
463    fn hash_to_group_bhp1024(input: &[bool]) -> Result<Group<Self>> {
464        BHP_1024.hash_uncompressed(input)
465    }
466
467    /// Returns the Pedersen hash for a given (up to) 64-bit input.
468    fn hash_to_group_ped64(input: &[bool]) -> Result<Group<Self>> {
469        PEDERSEN_64.hash_uncompressed(input)
470    }
471
472    /// Returns the Pedersen hash for a given (up to) 128-bit input.
473    fn hash_to_group_ped128(input: &[bool]) -> Result<Group<Self>> {
474        PEDERSEN_128.hash_uncompressed(input)
475    }
476
477    /// Returns the Poseidon hash with an input rate of 2 on the affine curve.
478    fn hash_to_group_psd2(input: &[Field<Self>]) -> Result<Group<Self>> {
479        POSEIDON_2.hash_to_group(input)
480    }
481
482    /// Returns the Poseidon hash with an input rate of 4 on the affine curve.
483    fn hash_to_group_psd4(input: &[Field<Self>]) -> Result<Group<Self>> {
484        POSEIDON_4.hash_to_group(input)
485    }
486
487    /// Returns the Poseidon hash with an input rate of 8 on the affine curve.
488    fn hash_to_group_psd8(input: &[Field<Self>]) -> Result<Group<Self>> {
489        POSEIDON_8.hash_to_group(input)
490    }
491
492    /// Returns the Poseidon hash with an input rate of 2 on the scalar field.
493    fn hash_to_scalar_psd2(input: &[Field<Self>]) -> Result<Scalar<Self>> {
494        POSEIDON_2.hash_to_scalar(input)
495    }
496
497    /// Returns the Poseidon hash with an input rate of 4 on the scalar field.
498    fn hash_to_scalar_psd4(input: &[Field<Self>]) -> Result<Scalar<Self>> {
499        POSEIDON_4.hash_to_scalar(input)
500    }
501
502    /// Returns the Poseidon hash with an input rate of 8 on the scalar field.
503    fn hash_to_scalar_psd8(input: &[Field<Self>]) -> Result<Scalar<Self>> {
504        POSEIDON_8.hash_to_scalar(input)
505    }
506
507    /// Returns a Merkle tree with a BHP leaf hasher of 1024-bits and a BHP path hasher of 512-bits.
508    fn merkle_tree_bhp<const DEPTH: u8>(leaves: &[Vec<bool>]) -> Result<BHPMerkleTree<Self, DEPTH>> {
509        MerkleTree::new(&*BHP_1024, &*BHP_512, leaves)
510    }
511
512    /// Returns a Merkle tree with a Poseidon leaf hasher with input rate of 4 and a Poseidon path hasher with input rate of 2.
513    fn merkle_tree_psd<const DEPTH: u8>(leaves: &[Vec<Field<Self>>]) -> Result<PoseidonMerkleTree<Self, DEPTH>> {
514        MerkleTree::new(&*POSEIDON_4, &*POSEIDON_2, leaves)
515    }
516
517    /// Returns `true` if the given Merkle path is valid for the given root and leaf.
518    fn verify_merkle_path_bhp<const DEPTH: u8>(
519        path: &MerklePath<Self, DEPTH>,
520        root: &Field<Self>,
521        leaf: &Vec<bool>,
522    ) -> bool {
523        path.verify(&*BHP_1024, &*BHP_512, root, leaf)
524    }
525
526    /// Returns `true` if the given Merkle path is valid for the given root and leaf.
527    fn verify_merkle_path_psd<const DEPTH: u8>(
528        path: &MerklePath<Self, DEPTH>,
529        root: &Field<Self>,
530        leaf: &Vec<Field<Self>>,
531    ) -> bool {
532        path.verify(&*POSEIDON_4, &*POSEIDON_2, root, leaf)
533    }
534}
535
536#[cfg(test)]
537mod tests {
538    use super::*;
539
540    type CurrentNetwork = MainnetV0;
541
542    #[test]
543    fn test_g_scalar_multiply() {
544        // Compute G^r.
545        let scalar = Scalar::rand(&mut TestRng::default());
546        let group = CurrentNetwork::g_scalar_multiply(&scalar);
547        assert_eq!(group, CurrentNetwork::g_powers()[0] * scalar);
548    }
549}
snarkvm_console_network/mainnet_v0.rs

snarkvm_console_network/
mainnet_v0.rs
