From b9cc39246a2e5e0a123f1df625674b945c293037 Mon Sep 17 00:00:00 2001 From: sword-smith Date: Wed, 16 Oct 2024 22:50:35 +0200 Subject: [PATCH] refactor: Move some test-case generaters under test-flag --- .../transaction/transaction_kernel.rs | 94 ++-- .../tasm/transaction_kernel_mast_hash.rs | 443 +++++++++--------- .../blockchain/transaction/validity/update.rs | 2 +- .../blockchain/type_scripts/neptune_coins.rs | 9 - src/tests/shared.rs | 29 +- src/util_types/mutator_set/addition_record.rs | 11 - src/util_types/mutator_set/removal_record.rs | 23 - src/util_types/test_shared/mutator_set.rs | 35 +- 8 files changed, 315 insertions(+), 331 deletions(-) diff --git a/src/models/blockchain/transaction/transaction_kernel.rs b/src/models/blockchain/transaction/transaction_kernel.rs index 8b61a2f7..43b0022b 100644 --- a/src/models/blockchain/transaction/transaction_kernel.rs +++ b/src/models/blockchain/transaction/transaction_kernel.rs @@ -1,10 +1,6 @@ use arbitrary::Arbitrary; use get_size::GetSize; use itertools::Itertools; -use rand::rngs::StdRng; -use rand::Rng; -use rand::RngCore; -use rand::SeedableRng; use serde::Deserialize; use serde::Serialize; use strum::EnumCount; @@ -16,24 +12,14 @@ use twenty_first::math::tip5::Digest; use super::primitive_witness::PrimitiveWitness; use super::PublicAnnouncement; -use crate::models::blockchain::type_scripts::neptune_coins::pseudorandom_amount; use crate::models::blockchain::type_scripts::neptune_coins::NeptuneCoins; use crate::models::proof_abstractions::mast_hash::HasDiscriminant; use crate::models::proof_abstractions::mast_hash::MastHash; use crate::models::proof_abstractions::timestamp::Timestamp; use crate::prelude::twenty_first; -use crate::util_types::mutator_set::addition_record::pseudorandom_addition_record; use crate::util_types::mutator_set::addition_record::AdditionRecord; -use crate::util_types::mutator_set::removal_record::pseudorandom_removal_record; use crate::util_types::mutator_set::removal_record::RemovalRecord; -pub fn pseudorandom_public_announcement(seed: [u8; 32]) -> PublicAnnouncement { - let mut rng: StdRng = SeedableRng::from_seed(seed); - let len = 10 + (rng.next_u32() % 50) as usize; - let message = (0..len).map(|_| rng.gen()).collect_vec(); - PublicAnnouncement { message } -} - #[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, GetSize, BFieldCodec, TasmObject)] pub struct TransactionKernel { pub inputs: Vec, @@ -107,47 +93,6 @@ impl MastHash for TransactionKernel { } } -pub fn pseudorandom_option(seed: [u8; 32], thing: T) -> Option { - let mut rng: StdRng = SeedableRng::from_seed(seed); - if rng.next_u32() % 2 == 0 { - None - } else { - Some(thing) - } -} - -pub fn pseudorandom_transaction_kernel( - seed: [u8; 32], - num_inputs: usize, - num_outputs: usize, - num_public_announcements: usize, -) -> TransactionKernel { - let mut rng: StdRng = SeedableRng::from_seed(seed); - let inputs = (0..num_inputs) - .map(|_| pseudorandom_removal_record(rng.gen::<[u8; 32]>())) - .collect_vec(); - let outputs = (0..num_outputs) - .map(|_| pseudorandom_addition_record(rng.gen::<[u8; 32]>())) - .collect_vec(); - let public_announcements = (0..num_public_announcements) - .map(|_| pseudorandom_public_announcement(rng.gen::<[u8; 32]>())) - .collect_vec(); - let fee = pseudorandom_amount(rng.gen::<[u8; 32]>()); - let coinbase = pseudorandom_option(rng.gen(), pseudorandom_amount(rng.gen::<[u8; 32]>())); - let timestamp: Timestamp = rng.gen(); - let mutator_set_hash: Digest = rng.gen(); - - TransactionKernel { - inputs, - outputs, - public_announcements, - fee, - coinbase, - timestamp, - mutator_set_hash, - } -} - impl<'a> Arbitrary<'a> for TransactionKernel { fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result { let num_inputs = u.int_in_range(0..=4)?; @@ -184,15 +129,54 @@ impl<'a> Arbitrary<'a> for TransactionKernel { #[cfg(test)] pub mod transaction_kernel_tests { use rand::random; + use rand::rngs::StdRng; use rand::thread_rng; use rand::Rng; use rand::RngCore; + use rand::SeedableRng; use super::*; + use crate::tests::shared::pseudorandom_amount; + use crate::tests::shared::pseudorandom_option; + use crate::tests::shared::pseudorandom_public_announcement; use crate::tests::shared::random_public_announcement; use crate::tests::shared::random_transaction_kernel; use crate::util_types::mutator_set::removal_record::AbsoluteIndexSet; use crate::util_types::mutator_set::shared::NUM_TRIALS; + use crate::util_types::test_shared::mutator_set::pseudorandom_addition_record; + use crate::util_types::test_shared::mutator_set::pseudorandom_removal_record; + + pub fn pseudorandom_transaction_kernel( + seed: [u8; 32], + num_inputs: usize, + num_outputs: usize, + num_public_announcements: usize, + ) -> TransactionKernel { + let mut rng: StdRng = SeedableRng::from_seed(seed); + let inputs = (0..num_inputs) + .map(|_| pseudorandom_removal_record(rng.gen::<[u8; 32]>())) + .collect_vec(); + let outputs = (0..num_outputs) + .map(|_| pseudorandom_addition_record(rng.gen::<[u8; 32]>())) + .collect_vec(); + let public_announcements = (0..num_public_announcements) + .map(|_| pseudorandom_public_announcement(rng.gen::<[u8; 32]>())) + .collect_vec(); + let fee = pseudorandom_amount(rng.gen::<[u8; 32]>()); + let coinbase = pseudorandom_option(rng.gen(), pseudorandom_amount(rng.gen::<[u8; 32]>())); + let timestamp: Timestamp = rng.gen(); + let mutator_set_hash: Digest = rng.gen(); + + TransactionKernel { + inputs, + outputs, + public_announcements, + fee, + coinbase, + timestamp, + mutator_set_hash, + } + } #[test] pub fn decode_public_announcement() { diff --git a/src/models/blockchain/transaction/validity/tasm/transaction_kernel_mast_hash.rs b/src/models/blockchain/transaction/validity/tasm/transaction_kernel_mast_hash.rs index 51695f79..15b8f7da 100644 --- a/src/models/blockchain/transaction/validity/tasm/transaction_kernel_mast_hash.rs +++ b/src/models/blockchain/transaction/validity/tasm/transaction_kernel_mast_hash.rs @@ -1,9 +1,3 @@ -use std::collections::HashMap; - -use num_traits::One; -use rand::rngs::StdRng; -use rand::Rng; -use rand::SeedableRng; use tasm_lib::data_type::DataType; use tasm_lib::hashing::algebraic_hasher::hash_varlen::HashVarlen; use tasm_lib::library::Library; @@ -11,49 +5,16 @@ use tasm_lib::list::get::Get; use tasm_lib::list::new::New; use tasm_lib::list::set::Set; use tasm_lib::list::set_length::SetLength; -use tasm_lib::rust_shadowing_helper_functions; -use tasm_lib::snippet_bencher::BenchmarkCase; use tasm_lib::traits::basic_snippet::BasicSnippet; -use tasm_lib::traits::function::Function; -use tasm_lib::traits::function::FunctionInitialState; -use tasm_lib::InitVmState; use triton_vm::prelude::*; -use twenty_first::math::bfield_codec::BFieldCodec; -use twenty_first::math::tip5::Digest; -use twenty_first::util_types::algebraic_hasher::AlgebraicHasher; -use crate::models::blockchain::shared::Hash; -use crate::models::blockchain::transaction::transaction_kernel::pseudorandom_transaction_kernel; use crate::models::blockchain::transaction::transaction_kernel::TransactionKernel; use crate::prelude::triton_vm; -use crate::prelude::twenty_first; /// Computes the mast hash of a transaction kernel object #[derive(Debug, Clone)] pub struct TransactionKernelMastHash; -impl TransactionKernelMastHash { - pub(crate) fn input_state_with_kernel_in_memory( - address: BFieldElement, - transaction_kernel_encoded: &[BFieldElement], - ) -> InitVmState { - assert!(address.value() > 1); - // populate memory - let mut memory: HashMap = HashMap::new(); - for (i, t) in transaction_kernel_encoded.iter().enumerate() { - memory.insert(address + BFieldElement::new(i as u64), *t); - } - memory.insert( - address - BFieldElement::new(1), - BFieldElement::new(transaction_kernel_encoded.len() as u64), - ); - - let mut stack = tasm_lib::empty_stack(); - stack.push(address); - InitVmState::with_stack_and_memory(stack, memory) - } -} - impl BasicSnippet for TransactionKernelMastHash { fn inputs(&self) -> Vec<(DataType, String)> { vec![(DataType::VoidPointer, "*transaction_kernel".to_string())] @@ -239,205 +200,241 @@ impl BasicSnippet for TransactionKernelMastHash { } } -impl Function for TransactionKernelMastHash { - fn rust_shadow( - &self, - stack: &mut Vec, - memory: &mut std::collections::HashMap< - triton_vm::prelude::BFieldElement, - triton_vm::prelude::BFieldElement, - >, - ) { - // read address - let address = stack.pop().unwrap(); - - let mut sequence = vec![]; - let size = memory - .get(&(address - BFieldElement::new(1))) - .unwrap() - .value(); - for i in 0..size { - sequence.push(*memory.get(&(BFieldElement::new(i) + address)).unwrap()); - } - let kernel = *TransactionKernel::decode(&sequence).unwrap(); - - // inputs - // let inputs_size = memory.get(&address).unwrap().value() as usize; - // let inputs_encoded = (0..inputs_size) - // .map(|i| { - // *memory - // .get(&(address + BFieldElement::new(i as u64))) - // .unwrap() - // }) - // .collect_vec(); - let inputs = kernel.inputs; - let inputs_encoded = inputs.encode(); - let inputs_hash = Hash::hash_varlen(&inputs_encoded); - // address += BFieldElement::one() + BFieldElement::new(inputs_size as u64); - - // outputs - // let outputs_size = memory.get(&address).unwrap().value() as usize; - // let outputs_encoded = (0..outputs_size) - // .map(|i| { - // *memory - // .get(&(address + BFieldElement::new(i as u64))) - // .unwrap() - // }) - // .collect_vec(); - let outputs = kernel.outputs; - let outputs_encoded = outputs.encode(); - let outputs_hash = Hash::hash_varlen(&outputs_encoded); - // address += BFieldElement::one() + BFieldElement::new(outputs_size as u64); - - // public_announcements - // let public_announcements_size = memory.get(&address).unwrap().value() as usize; - // let public_announcements_encoded = (0..public_announcements_size) - // .map(|i| { - // *memory - // .get(&(address + BFieldElement::new(i as u64))) - // .unwrap() - // }) - // .collect_vec(); - let public_announcements = kernel.public_announcements; - let public_announcements_encoded = public_announcements.encode(); - let public_announcements_hash = Hash::hash_varlen(&public_announcements_encoded); - // address += - // BFieldElement::one() + BFieldElement::new(public_announcements_size as u64); - - // fee - // let fee_size = memory.get(&address).unwrap().value() as usize; - // let fee_encoded = (0..fee_size) - // .map(|i| { - // *memory - // .get(&(address + BFieldElement::new(i as u64))) - // .unwrap() - // }) - // .collect_vec(); - let fee = kernel.fee; - let fee_encoded = fee.encode(); - let fee_hash = Hash::hash_varlen(&fee_encoded); - // address += BFieldElement::one() + BFieldElement::new(fee_size as u64); - - // coinbase - // let coinbase_size = memory.get(&address).unwrap().value() as usize; - // let coinbase_encoded = (0..coinbase_size) - // .map(|i| { - // *memory - // .get(&(address + BFieldElement::new(i as u64))) - // .unwrap() - // }) - // .collect_vec(); - let coinbase = kernel.coinbase; - let coinbase_encoded = coinbase.encode(); - let coinbase_hash = Hash::hash_varlen(&coinbase_encoded); - // address += BFieldElement::one() + BFieldElement::new(coinbase_size as u64); - - // timestamp - // let timestamp_size = memory.get(&address).unwrap().value() as usize; - // assert_eq!(timestamp_size, 1); - // let timestamp_encoded = (0..timestamp_size) - // .map(|i| { - // *memory - // .get(&(address + BFieldElement::new(i as u64))) - // .unwrap() - // }) - // .collect_vec(); - let timestamp = kernel.timestamp; - let timestamp_encoded = timestamp.encode(); - let timestamp_hash = Hash::hash_varlen(×tamp_encoded); - // address += BFieldElement::one() + BFieldElement::new(timestamp_size as u64); - - // mutator_set_hash - // let mutator_set_hash_size = memory.get(&address).unwrap().value() as usize; - // let mutator_set_hash_encoded = (0..mutator_set_hash_size) - // .map(|i| { - // *memory - // .get(&(address + BFieldElement::new(i as u64))) - // .unwrap() - // }) - // .collect_vec(); - let mutator_set_hash = kernel.mutator_set_hash; - let mutator_set_hash_encoded = mutator_set_hash.encode(); - let mutator_set_hash_hash = Hash::hash_varlen(&mutator_set_hash_encoded); - // address += BFieldElement::one() + BFieldElement::new(mutator_set_hash_size as u64); - - // padding - let zero = Digest::default(); - - // Merkleize - let leafs = [ - inputs_hash, - outputs_hash, - public_announcements_hash, - fee_hash, - coinbase_hash, - timestamp_hash, - mutator_set_hash_hash, - zero, - ]; - let mut nodes = [[zero; 8], leafs].concat(); - for i in (1..=7).rev() { - nodes[i] = Hash::hash_pair(nodes[2 * i], nodes[2 * i + 1]); - } - let root = nodes[1].to_owned(); - - // populate memory with merkle tree - let list_address = rust_shadowing_helper_functions::dyn_malloc::dynamic_allocator(memory); - rust_shadowing_helper_functions::list::list_new(list_address, memory); - rust_shadowing_helper_functions::list::list_set_length(list_address, 16, memory); - for (i, node) in nodes.into_iter().enumerate().skip(1) { - for j in 0..Digest::LEN { - memory.insert( - list_address - + BFieldElement::one() - + BFieldElement::new((i * Digest::LEN + j) as u64), - node.values()[j], - ); - } - } - - // write digest to stack - stack.push(root.values()[4]); - stack.push(root.values()[3]); - stack.push(root.values()[2]); - stack.push(root.values()[1]); - stack.push(root.values()[0]); - } - - fn pseudorandom_initial_state( - &self, - seed: [u8; 32], - _bench_case: Option, - ) -> FunctionInitialState { - let mut rng: StdRng = SeedableRng::from_seed(seed); - let input_state = Self::input_state_with_kernel_in_memory( - BFieldElement::new(rng.gen_range(0..(1 << 20))), - &twenty_first::math::bfield_codec::BFieldCodec::encode( - &pseudorandom_transaction_kernel(rand::Rng::gen::<[u8; 32]>(&mut rng), 4, 4, 2), - ), - ); - FunctionInitialState { - stack: input_state.stack, - memory: input_state.nondeterminism.ram, - } - } -} - #[cfg(test)] mod tests { + use std::collections::HashMap; + + use crate::models::blockchain::shared::Hash; + use crate::models::blockchain::transaction::transaction_kernel::transaction_kernel_tests::pseudorandom_transaction_kernel; + use crate::prelude::twenty_first; + use num_traits::One; use rand::rngs::StdRng; use rand::Rng; use rand::SeedableRng; + use tasm_lib::rust_shadowing_helper_functions; + use tasm_lib::snippet_bencher::BenchmarkCase; use tasm_lib::test_helpers::test_rust_equivalence_given_complete_state; + use tasm_lib::traits::function::Function; + use tasm_lib::traits::function::FunctionInitialState; use tasm_lib::traits::function::ShadowedFunction; use tasm_lib::traits::rust_shadow::RustShadow; use tasm_lib::twenty_first::math::tip5::Tip5; + use tasm_lib::InitVmState; use twenty_first::math::bfield_codec::BFieldCodec; + use twenty_first::math::tip5::Digest; + use twenty_first::util_types::algebraic_hasher::AlgebraicHasher; use twenty_first::util_types::algebraic_hasher::Domain; use super::*; use crate::models::proof_abstractions::mast_hash::MastHash; + impl TransactionKernelMastHash { + pub(crate) fn input_state_with_kernel_in_memory( + address: BFieldElement, + transaction_kernel_encoded: &[BFieldElement], + ) -> InitVmState { + assert!(address.value() > 1); + // populate memory + let mut memory: HashMap = HashMap::new(); + for (i, t) in transaction_kernel_encoded.iter().enumerate() { + memory.insert(address + BFieldElement::new(i as u64), *t); + } + memory.insert( + address - BFieldElement::new(1), + BFieldElement::new(transaction_kernel_encoded.len() as u64), + ); + + let mut stack = tasm_lib::empty_stack(); + stack.push(address); + InitVmState::with_stack_and_memory(stack, memory) + } + } + + impl Function for TransactionKernelMastHash { + fn rust_shadow( + &self, + stack: &mut Vec, + memory: &mut std::collections::HashMap< + triton_vm::prelude::BFieldElement, + triton_vm::prelude::BFieldElement, + >, + ) { + // read address + let address = stack.pop().unwrap(); + + let mut sequence = vec![]; + let size = memory + .get(&(address - BFieldElement::new(1))) + .unwrap() + .value(); + for i in 0..size { + sequence.push(*memory.get(&(BFieldElement::new(i) + address)).unwrap()); + } + let kernel = *TransactionKernel::decode(&sequence).unwrap(); + + // inputs + // let inputs_size = memory.get(&address).unwrap().value() as usize; + // let inputs_encoded = (0..inputs_size) + // .map(|i| { + // *memory + // .get(&(address + BFieldElement::new(i as u64))) + // .unwrap() + // }) + // .collect_vec(); + let inputs = kernel.inputs; + let inputs_encoded = inputs.encode(); + let inputs_hash = Hash::hash_varlen(&inputs_encoded); + // address += BFieldElement::one() + BFieldElement::new(inputs_size as u64); + + // outputs + // let outputs_size = memory.get(&address).unwrap().value() as usize; + // let outputs_encoded = (0..outputs_size) + // .map(|i| { + // *memory + // .get(&(address + BFieldElement::new(i as u64))) + // .unwrap() + // }) + // .collect_vec(); + let outputs = kernel.outputs; + let outputs_encoded = outputs.encode(); + let outputs_hash = Hash::hash_varlen(&outputs_encoded); + // address += BFieldElement::one() + BFieldElement::new(outputs_size as u64); + + // public_announcements + // let public_announcements_size = memory.get(&address).unwrap().value() as usize; + // let public_announcements_encoded = (0..public_announcements_size) + // .map(|i| { + // *memory + // .get(&(address + BFieldElement::new(i as u64))) + // .unwrap() + // }) + // .collect_vec(); + let public_announcements = kernel.public_announcements; + let public_announcements_encoded = public_announcements.encode(); + let public_announcements_hash = Hash::hash_varlen(&public_announcements_encoded); + // address += + // BFieldElement::one() + BFieldElement::new(public_announcements_size as u64); + + // fee + // let fee_size = memory.get(&address).unwrap().value() as usize; + // let fee_encoded = (0..fee_size) + // .map(|i| { + // *memory + // .get(&(address + BFieldElement::new(i as u64))) + // .unwrap() + // }) + // .collect_vec(); + let fee = kernel.fee; + let fee_encoded = fee.encode(); + let fee_hash = Hash::hash_varlen(&fee_encoded); + // address += BFieldElement::one() + BFieldElement::new(fee_size as u64); + + // coinbase + // let coinbase_size = memory.get(&address).unwrap().value() as usize; + // let coinbase_encoded = (0..coinbase_size) + // .map(|i| { + // *memory + // .get(&(address + BFieldElement::new(i as u64))) + // .unwrap() + // }) + // .collect_vec(); + let coinbase = kernel.coinbase; + let coinbase_encoded = coinbase.encode(); + let coinbase_hash = Hash::hash_varlen(&coinbase_encoded); + // address += BFieldElement::one() + BFieldElement::new(coinbase_size as u64); + + // timestamp + // let timestamp_size = memory.get(&address).unwrap().value() as usize; + // assert_eq!(timestamp_size, 1); + // let timestamp_encoded = (0..timestamp_size) + // .map(|i| { + // *memory + // .get(&(address + BFieldElement::new(i as u64))) + // .unwrap() + // }) + // .collect_vec(); + let timestamp = kernel.timestamp; + let timestamp_encoded = timestamp.encode(); + let timestamp_hash = Hash::hash_varlen(×tamp_encoded); + // address += BFieldElement::one() + BFieldElement::new(timestamp_size as u64); + + // mutator_set_hash + // let mutator_set_hash_size = memory.get(&address).unwrap().value() as usize; + // let mutator_set_hash_encoded = (0..mutator_set_hash_size) + // .map(|i| { + // *memory + // .get(&(address + BFieldElement::new(i as u64))) + // .unwrap() + // }) + // .collect_vec(); + let mutator_set_hash = kernel.mutator_set_hash; + let mutator_set_hash_encoded = mutator_set_hash.encode(); + let mutator_set_hash_hash = Hash::hash_varlen(&mutator_set_hash_encoded); + // address += BFieldElement::one() + BFieldElement::new(mutator_set_hash_size as u64); + + // padding + let zero = Digest::default(); + + // Merkleize + let leafs = [ + inputs_hash, + outputs_hash, + public_announcements_hash, + fee_hash, + coinbase_hash, + timestamp_hash, + mutator_set_hash_hash, + zero, + ]; + let mut nodes = [[zero; 8], leafs].concat(); + for i in (1..=7).rev() { + nodes[i] = Hash::hash_pair(nodes[2 * i], nodes[2 * i + 1]); + } + let root = nodes[1].to_owned(); + + // populate memory with merkle tree + let list_address = + rust_shadowing_helper_functions::dyn_malloc::dynamic_allocator(memory); + rust_shadowing_helper_functions::list::list_new(list_address, memory); + rust_shadowing_helper_functions::list::list_set_length(list_address, 16, memory); + for (i, node) in nodes.into_iter().enumerate().skip(1) { + for j in 0..Digest::LEN { + memory.insert( + list_address + + BFieldElement::one() + + BFieldElement::new((i * Digest::LEN + j) as u64), + node.values()[j], + ); + } + } + + // write digest to stack + stack.push(root.values()[4]); + stack.push(root.values()[3]); + stack.push(root.values()[2]); + stack.push(root.values()[1]); + stack.push(root.values()[0]); + } + + fn pseudorandom_initial_state( + &self, + seed: [u8; 32], + _bench_case: Option, + ) -> FunctionInitialState { + let mut rng: StdRng = SeedableRng::from_seed(seed); + let input_state = Self::input_state_with_kernel_in_memory( + BFieldElement::new(rng.gen_range(0..(1 << 20))), + &twenty_first::math::bfield_codec::BFieldCodec::encode( + &pseudorandom_transaction_kernel(rand::Rng::gen::<[u8; 32]>(&mut rng), 4, 4, 2), + ), + ); + FunctionInitialState { + stack: input_state.stack, + memory: input_state.nondeterminism.ram, + } + } + } + #[test] fn verify_agreement_with_tx_kernel_mast_hash() { let mut seed = [99u8; 32]; diff --git a/src/models/blockchain/transaction/validity/update.rs b/src/models/blockchain/transaction/validity/update.rs index ca781bb1..83b9ac56 100644 --- a/src/models/blockchain/transaction/validity/update.rs +++ b/src/models/blockchain/transaction/validity/update.rs @@ -721,7 +721,7 @@ pub(crate) mod test { use crate::models::proof_abstractions::timestamp::Timestamp; use crate::models::proof_abstractions::SecretWitness; use crate::util_types::mutator_set::addition_record::AdditionRecord; - use crate::util_types::mutator_set::removal_record::pseudorandom_removal_record; + use crate::util_types::test_shared::mutator_set::pseudorandom_removal_record; impl UpdateWitness { pub(crate) fn new_kernel_mast_hash(&self) -> Digest { diff --git a/src/models/blockchain/type_scripts/neptune_coins.rs b/src/models/blockchain/type_scripts/neptune_coins.rs index be5f5e35..705c3e2a 100644 --- a/src/models/blockchain/type_scripts/neptune_coins.rs +++ b/src/models/blockchain/type_scripts/neptune_coins.rs @@ -15,9 +15,6 @@ use num_traits::CheckedSub; use num_traits::FromPrimitive; use num_traits::One; use num_traits::Zero; -use rand::rngs::StdRng; -use rand::Rng; -use rand::SeedableRng; use regex::Regex; use serde::Deserialize; use serde::Serialize; @@ -367,12 +364,6 @@ impl std::fmt::Debug for NeptuneCoins { } } -pub fn pseudorandom_amount(seed: [u8; 32]) -> NeptuneCoins { - let mut rng: StdRng = SeedableRng::from_seed(seed); - let number: u128 = rng.gen::() >> 10; - NeptuneCoins(number) -} - impl<'a> Arbitrary<'a> for NeptuneCoins { fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result { let nau: u128 = u.arbitrary()?; diff --git a/src/tests/shared.rs b/src/tests/shared.rs index 312d29e2..3eaa4a00 100644 --- a/src/tests/shared.rs +++ b/src/tests/shared.rs @@ -56,15 +56,12 @@ use crate::models::blockchain::block::mutator_set_update::MutatorSetUpdate; use crate::models::blockchain::block::Block; use crate::models::blockchain::block::BlockProof; use crate::models::blockchain::transaction::lock_script::LockScript; -use crate::models::blockchain::transaction::transaction_kernel::pseudorandom_option; -use crate::models::blockchain::transaction::transaction_kernel::pseudorandom_public_announcement; -use crate::models::blockchain::transaction::transaction_kernel::pseudorandom_transaction_kernel; +use crate::models::blockchain::transaction::transaction_kernel::transaction_kernel_tests::pseudorandom_transaction_kernel; use crate::models::blockchain::transaction::transaction_kernel::TransactionKernel; use crate::models::blockchain::transaction::utxo::Utxo; use crate::models::blockchain::transaction::PublicAnnouncement; use crate::models::blockchain::transaction::Transaction; use crate::models::blockchain::transaction::TransactionProof; -use crate::models::blockchain::type_scripts::neptune_coins::pseudorandom_amount; use crate::models::blockchain::type_scripts::neptune_coins::NeptuneCoins; use crate::models::blockchain::type_scripts::time_lock::arbitrary_primitive_witness_with_expired_timelocks; use crate::models::channel::MainToPeerTask; @@ -90,7 +87,6 @@ use crate::models::state::wallet::wallet_state::WalletState; use crate::models::state::wallet::WalletSecret; use crate::models::state::GlobalStateLock; use crate::prelude::twenty_first; -use crate::util_types::mutator_set::addition_record::pseudorandom_addition_record; use crate::util_types::mutator_set::addition_record::AdditionRecord; use crate::util_types::mutator_set::commit; use crate::util_types::mutator_set::mutator_set_accumulator::MutatorSetAccumulator; @@ -397,6 +393,21 @@ impl stream::Stream for Mock { } } +pub fn pseudorandom_option(seed: [u8; 32], thing: T) -> Option { + let mut rng: StdRng = SeedableRng::from_seed(seed); + if rng.next_u32() % 2 == 0 { + None + } else { + Some(thing) + } +} + +pub fn pseudorandom_amount(seed: [u8; 32]) -> NeptuneCoins { + let mut rng: StdRng = SeedableRng::from_seed(seed); + let number: u128 = rng.gen::() >> 10; + NeptuneCoins::from_nau(number.into()).unwrap() +} + pub fn pseudorandom_utxo(seed: [u8; 32]) -> Utxo { let mut rng: StdRng = SeedableRng::from_seed(seed); Utxo { @@ -413,9 +424,11 @@ pub fn random_transaction_kernel() -> TransactionKernel { pseudorandom_transaction_kernel(rng.gen(), num_inputs, num_outputs, num_public_announcements) } -pub fn random_addition_record() -> AdditionRecord { - let mut rng = thread_rng(); - pseudorandom_addition_record(rng.gen::<[u8; 32]>()) +pub fn pseudorandom_public_announcement(seed: [u8; 32]) -> PublicAnnouncement { + let mut rng: StdRng = SeedableRng::from_seed(seed); + let len = 10 + (rng.next_u32() % 50) as usize; + let message = (0..len).map(|_| rng.gen()).collect_vec(); + PublicAnnouncement { message } } pub fn random_public_announcement() -> PublicAnnouncement { diff --git a/src/util_types/mutator_set/addition_record.rs b/src/util_types/mutator_set/addition_record.rs index e7804c2d..ce14a125 100644 --- a/src/util_types/mutator_set/addition_record.rs +++ b/src/util_types/mutator_set/addition_record.rs @@ -1,8 +1,5 @@ use arbitrary::Arbitrary; use get_size::GetSize; -use rand::rngs::StdRng; -use rand::Rng; -use rand::SeedableRng; use serde::Deserialize; use serde::Serialize; use tasm_lib::prelude::TasmObject; @@ -37,14 +34,6 @@ impl AdditionRecord { } } -pub fn pseudorandom_addition_record(seed: [u8; 32]) -> AdditionRecord { - let mut rng: StdRng = SeedableRng::from_seed(seed); - let ar: Digest = rng.gen(); - AdditionRecord { - canonical_commitment: ar, - } -} - #[cfg(test)] mod addition_record_tests { use rand::random; diff --git a/src/util_types/mutator_set/removal_record.rs b/src/util_types/mutator_set/removal_record.rs index 63e219da..afe6e6ca 100644 --- a/src/util_types/mutator_set/removal_record.rs +++ b/src/util_types/mutator_set/removal_record.rs @@ -6,10 +6,6 @@ use std::ops::IndexMut; use arbitrary::Arbitrary; use get_size::GetSize; use itertools::Itertools; -use rand::rngs::StdRng; -use rand::Rng; -use rand::RngCore; -use rand::SeedableRng; use serde::de::SeqAccess; use serde::de::Visitor; use serde::ser::SerializeTuple; @@ -24,7 +20,6 @@ use twenty_first::util_types::mmr; use twenty_first::util_types::mmr::mmr_accumulator::MmrAccumulator; use twenty_first::util_types::mmr::mmr_trait::Mmr; -use super::chunk_dictionary::pseudorandom_chunk_dictionary; use super::chunk_dictionary::ChunkDictionary; use super::mutator_set_accumulator::MutatorSetAccumulator; use super::shared::get_batch_mutation_argument_for_removal_record; @@ -357,24 +352,6 @@ impl RemovalRecord { } } -/// Generate a pseudorandom removal record from the given seed, for testing purposes. -pub fn pseudorandom_removal_record(seed: [u8; 32]) -> RemovalRecord { - let mut rng: StdRng = SeedableRng::from_seed(seed); - let absolute_indices = AbsoluteIndexSet::new( - &(0..NUM_TRIALS as usize) - .map(|_| ((rng.next_u64() as u128) << 64) ^ rng.next_u64() as u128) - .collect_vec() - .try_into() - .unwrap(), - ); - let target_chunks = pseudorandom_chunk_dictionary(rng.gen::<[u8; 32]>()); - - RemovalRecord { - absolute_indices, - target_chunks, - } -} - #[cfg(test)] mod removal_record_tests { use itertools::Itertools; diff --git a/src/util_types/test_shared/mutator_set.rs b/src/util_types/test_shared/mutator_set.rs index 83f978a7..2970b2fa 100644 --- a/src/util_types/test_shared/mutator_set.rs +++ b/src/util_types/test_shared/mutator_set.rs @@ -18,6 +18,7 @@ use crate::database::NeptuneLevelDb; use crate::models::blockchain::shared::Hash; use crate::prelude::twenty_first; use crate::util_types::mutator_set::active_window::ActiveWindow; +use crate::util_types::mutator_set::addition_record::AdditionRecord; use crate::util_types::mutator_set::archival_mutator_set::ArchivalMutatorSet; use crate::util_types::mutator_set::chunk::Chunk; use crate::util_types::mutator_set::chunk_dictionary::pseudorandom_chunk_dictionary; @@ -26,10 +27,11 @@ use crate::util_types::mutator_set::commit; use crate::util_types::mutator_set::ms_membership_proof::pseudorandom_mutator_set_membership_proof; use crate::util_types::mutator_set::ms_membership_proof::MsMembershipProof; use crate::util_types::mutator_set::mutator_set_accumulator::MutatorSetAccumulator; -use crate::util_types::mutator_set::removal_record::pseudorandom_removal_record; +use crate::util_types::mutator_set::removal_record::AbsoluteIndexSet; use crate::util_types::mutator_set::removal_record::RemovalRecord; use crate::util_types::mutator_set::rusty_archival_mutator_set::RustyArchivalMutatorSet; use crate::util_types::mutator_set::shared::CHUNK_SIZE; +use crate::util_types::mutator_set::shared::NUM_TRIALS; use crate::util_types::mutator_set::shared::WINDOW_SIZE; pub fn random_chunk_dictionary() -> ChunkDictionary { @@ -121,6 +123,37 @@ pub fn random_mmra() -> MmrAccumulator { pseudorandom_mmra(thread_rng().gen()) } +/// Generate a pseudorandom removal record from the given seed, for testing purposes. +pub(crate) fn pseudorandom_removal_record(seed: [u8; 32]) -> RemovalRecord { + let mut rng: StdRng = SeedableRng::from_seed(seed); + let absolute_indices = AbsoluteIndexSet::new( + &(0..NUM_TRIALS as usize) + .map(|_| ((rng.next_u64() as u128) << 64) ^ rng.next_u64() as u128) + .collect_vec() + .try_into() + .unwrap(), + ); + let target_chunks = pseudorandom_chunk_dictionary(rng.gen::<[u8; 32]>()); + + RemovalRecord { + absolute_indices, + target_chunks, + } +} + +pub fn pseudorandom_addition_record(seed: [u8; 32]) -> AdditionRecord { + let mut rng: StdRng = SeedableRng::from_seed(seed); + let ar: Digest = rng.gen(); + AdditionRecord { + canonical_commitment: ar, + } +} + +pub fn random_addition_record() -> AdditionRecord { + let mut rng = thread_rng(); + pseudorandom_addition_record(rng.gen::<[u8; 32]>()) +} + pub fn pseudorandom_mmra(seed: [u8; 32]) -> MmrAccumulator { let mut rng: StdRng = SeedableRng::from_seed(seed); let leaf_count = rng.next_u32() as u64;