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

snarkvm_console_network/
canary_v0.rs
