snarkvm_console_network/
mainnet_v0.rs

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

snarkvm_console_network/
mainnet_v0.rs
