From 4f3722033a1dcfd869860d5886accc7d19363423 Mon Sep 17 00:00:00 2001 From: collin Date: Wed, 12 Aug 2020 19:04:41 -0700 Subject: [PATCH] add verify_local_data_commitment test --- .../local_data_commitment.rs | 31 +- .../state_leaf_values.rs | 6 +- .../record_commitment/record_commitment.rs | 1 + .../inputs/{test.state => test_record.state} | 2 +- state/tests/inputs/test_state.state | 23 ++ state/tests/mod.rs | 2 +- state/tests/test.rs | 316 ------------------ .../test_verify_local_data_commitment.rs | 204 +++++++++++ state/tests/test_verify_record_commitment.rs | 7 +- 9 files changed, 242 insertions(+), 350 deletions(-) rename state/tests/inputs/{test.state => test_record.state} (97%) create mode 100644 state/tests/inputs/test_state.state delete mode 100644 state/tests/test.rs create mode 100644 state/tests/test_verify_local_data_commitment.rs diff --git a/state/src/local_data_commitment/local_data_commitment.rs b/state/src/local_data_commitment/local_data_commitment.rs index 1cf1888597..f111e45f81 100644 --- a/state/src/local_data_commitment/local_data_commitment.rs +++ b/state/src/local_data_commitment/local_data_commitment.rs @@ -5,7 +5,6 @@ use snarkos_algorithms::commitment_tree::CommitmentMerklePath; use snarkos_dpc::base_dpc::instantiated::{Components, LocalDataCRH, LocalDataCommitment, RecordCommitment}; use snarkos_models::{ algorithms::{CommitmentScheme, CRH}, - curves::Fp256, dpc::DPCComponents, }; use snarkos_utilities::{bytes::ToBytes, to_bytes, FromBytes}; @@ -33,14 +32,13 @@ pub fn verify_local_data_commitment( // parse typed state leaf values let typed_state_leaf = typed_input.get_state_leaf(); let state_leaf_values = StateLeafValues::try_from(typed_state_leaf)?; - let _path: Vec> = state_leaf_values.path; + let path: Vec = state_leaf_values.path; let memo: Vec = state_leaf_values.memo; let network_id: u8 = state_leaf_values.network_id; let leaf_randomness: Vec = state_leaf_values.leaf_randomness; // Select local data commitment input bytes let is_death = leaf_index < (Components::NUM_INPUT_RECORDS as u32); - let input_bytes = if is_death { to_bytes![record_serial_number, record_commitment, memo, network_id]? } else { @@ -48,35 +46,16 @@ pub fn verify_local_data_commitment( }; // Construct local data commitment leaf - let local_data_leaf_randomness = Fp256::read(&leaf_randomness[..])?; - + let local_data_leaf_randomness = ::Randomness::read(&leaf_randomness[..])?; let local_data_commitment_leaf = LocalDataCommitment::commit(&local_data_commitment_params, &input_bytes, &local_data_leaf_randomness)?; // Construct record commitment merkle path - - // let local_data_merkle_path = CommitmentMerklePath::from(path); // Ideally we want something like this - - // Initialize failing blank values for now - let leaves = ( - ::Output::default(), - ::Output::default(), - ); - - let inner_hashes = ( - ::Output::default(), - ::Output::default(), - ); - - let local_data_merkle_path = CommitmentMerklePath:: { - leaves, - inner_hashes, - parameters: local_data_crh_params, - }; + let mut local_data_merkle_path = CommitmentMerklePath::::read(&path[..])?; + local_data_merkle_path.parameters = Some(local_data_crh_params); // Check record commitment merkle path is valid for the given local data commitment root - let local_data_commitment_root = Fp256::read(&root[..])?; - + let local_data_commitment_root = ::Output::read(&root[..])?; let result = local_data_merkle_path.verify(&local_data_commitment_root, &local_data_commitment_leaf)?; Ok(result) diff --git a/state/src/local_data_commitment/state_leaf_values.rs b/state/src/local_data_commitment/state_leaf_values.rs index 4babf398f2..b52badd1da 100644 --- a/state/src/local_data_commitment/state_leaf_values.rs +++ b/state/src/local_data_commitment/state_leaf_values.rs @@ -1,4 +1,4 @@ -use crate::{find_input, input_to_integer_string, input_to_nested_u8_vec, input_to_u8_vec, StateLeafValuesError}; +use crate::{find_input, input_to_integer_string, input_to_u8_vec, StateLeafValuesError}; use leo_typed::StateLeaf as TypedStateLeaf; use std::convert::TryFrom; @@ -9,7 +9,7 @@ static NETWORK_ID_PARAMETER_STRING: &str = "network_id"; static LEAF_RANDOMNESS_PARAMETER_STRING: &str = "leaf_randomness"; pub struct StateLeafValues { - pub path: Vec>, + pub path: Vec, pub memo: Vec, pub network_id: u8, pub leaf_randomness: Vec, @@ -23,7 +23,7 @@ impl TryFrom<&TypedStateLeaf> for StateLeafValues { // Lookup path let path_value = find_input(PATH_PARAMETER_STRING.to_owned(), ¶meters)?; - let path = input_to_nested_u8_vec(path_value)?; + let path = input_to_u8_vec(path_value)?; // Lookup memo let memo_value = find_input(MEMO_PARAMETER_STRING.to_owned(), ¶meters)?; diff --git a/state/src/record_commitment/record_commitment.rs b/state/src/record_commitment/record_commitment.rs index 9adea95076..89d671ea71 100644 --- a/state/src/record_commitment/record_commitment.rs +++ b/state/src/record_commitment/record_commitment.rs @@ -14,6 +14,7 @@ pub fn verify_record_commitment( // generate a dpc record from the typed record let record = DPCRecordValues::try_from(typed_record)?; + // verify record commitment let record_commitment_input = to_bytes![ record.owner, record.is_dummy, diff --git a/state/tests/inputs/test.state b/state/tests/inputs/test_record.state similarity index 97% rename from state/tests/inputs/test.state rename to state/tests/inputs/test_record.state index bcf404045f..dcc712d3de 100644 --- a/state/tests/inputs/test.state +++ b/state/tests/inputs/test_record.state @@ -17,7 +17,7 @@ serial_number_nonce: u8[32] = [13, 163, 44, 146, 30, 254, 39, 255, 41, 20, 154, commitment_randomness: u8[32] = [55, 189, 0, 182, 148, 137, 120, 223, 121, 7, 140, 240, 100, 202, 196, 41, 236, 128, 38, 189, 60, 59, 23, 210, 25, 102, 65, 117, 38, 140, 136, 1]; [state_leaf] -path: u8[32][2] = [ [0u8; 32], [0u8; 32] ]; +path: u8[128] = [0u8; 128]; memo: u8[32] = [0u8; 32]; network_id: u8 = 0; leaf_randomness: u8[32] = [0u8; 32]; \ No newline at end of file diff --git a/state/tests/inputs/test_state.state b/state/tests/inputs/test_state.state new file mode 100644 index 0000000000..4336865638 --- /dev/null +++ b/state/tests/inputs/test_state.state @@ -0,0 +1,23 @@ +[[public]] +[state] +leaf_index: u32 = 0; +root: u8[32] = [70, 27, 231, 101, 102, 20, 37, 118, 77, 38, 56, 106, 49, 17, 135, 81, 134, 61, 255, 147, 230, 94, 218, 157, 98, 31, 132, 10, 116, 201, 78, 15]; + +[[private]] +[record] +serial_number: u8[64] = [98, 228, 41, 139, 42, 245, 63, 73, 45, 255, 134, 169, 18, 86, 90, 209, 31, 207, 161, 83, 183, 126, 53, 86, 142, 64, 59, 29, 185, 204, 179, 8, 43, 199, 156, 127, 124, 7, 91, 56, 27, 101, 57, 52, 166, 145, 153, 137, 17, 1, 140, 42, 205, 91, 32, 99, 22, 119, 141, 253, 235, 213, 112, 14]; +commitment: u8[32] = [233, 180, 207, 91, 31, 4, 177, 7, 21, 177, 170, 63, 134, 227, 249, 217, 193, 113, 220, 188, 97, 228, 70, 43, 160, 112, 228, 151, 110, 58, 85, 7]; +owner: address = aleo1daxej63vwrmn2zhl4dymygagh89k5d2vaw6rjauueme7le6k2q8sjn0ng9; +is_dummy: bool = false; +value: u64 = 18186969098991041491; +payload: u8[32] = [192, 118, 4, 191, 56, 79, 165, 142, 20, 92, 140, 207, 81, 125, 226, 247, 184, 40, 101, 235, 205, 174, 175, 180, 18, 104, 251, 132, 117, 163, 219, 125]; +birth_program_id: u8[48] = [89, 70, 116, 103, 190, 86, 194, 133, 37, 77, 113, 166, 160, 156, 98, 252, 16, 219, 94, 12, 214, 12, 151, 139, 239, 1, 79, 79, 86, 235, 209, 168, 240, 156, 224, 86, 35, 63, 185, 196, 0, 10, 148, 56, 92, 199, 45, 0]; +death_program_id: u8[48] = [89, 70, 116, 103, 190, 86, 194, 133, 37, 77, 113, 166, 160, 156, 98, 252, 16, 219, 94, 12, 214, 12, 151, 139, 239, 1, 79, 79, 86, 235, 209, 168, 240, 156, 224, 86, 35, 63, 185, 196, 0, 10, 148, 56, 92, 199, 45, 0]; +serial_number_nonce: u8[32] = [74, 128, 103, 188, 105, 165, 185, 183, 83, 178, 164, 202, 65, 224, 154, 216, 132, 146, 103, 158, 153, 229, 73, 162, 0, 182, 176, 162, 17, 201, 27, 6]; +commitment_randomness: u8[32] = [129, 174, 175, 20, 1, 168, 248, 69, 51, 186, 30, 34, 82, 6, 148, 174, 128, 163, 156, 197, 94, 129, 117, 226, 240, 95, 203, 196, 65, 222, 96, 4]; + +[state_leaf] +path: u8[128] = [144, 36, 140, 16, 110, 109, 215, 172, 251, 234, 246, 145, 192, 60, 79, 255, 58, 199, 52, 107, 224, 235, 152, 27, 232, 42, 96, 225, 170, 62, 118, 12, 8, 205, 94, 96, 200, 133, 229, 122, 179, 198, 124, 104, 197, 86, 67, 1, 52, 61, 168, 92, 201, 240, 61, 116, 221, 76, 172, 83, 174, 194, 118, 5, 221, 106, 153, 186, 50, 200, 155, 245, 255, 253, 169, 40, 236, 88, 58, 147, 46, 160, 55, 132, 157, 0, 134, 15, 40, 223, 53, 175, 220, 13, 222, 15, 143, 179, 79, 184, 75, 238, 87, 199, 102, 168, 167, 60, 232, 62, 64, 107, 12, 182, 200, 155, 107, 138, 224, 193, 233, 221, 54, 96, 206, 191, 83, 9]; +memo: u8[32] = [0u8; 32]; +network_id: u8 = 0; +leaf_randomness: u8[32] = [102, 202, 135, 202, 235, 133, 143, 160, 137, 212, 216, 158, 17, 44, 104, 126, 157, 109, 93, 213, 174, 57, 194, 113, 75, 184, 26, 204, 143, 131, 95, 1]; \ No newline at end of file diff --git a/state/tests/mod.rs b/state/tests/mod.rs index 39d7ec66f8..3f3fd2339d 100644 --- a/state/tests/mod.rs +++ b/state/tests/mod.rs @@ -1,3 +1,3 @@ -// mod test; +mod test_verify_local_data_commitment; mod test_verify_record_commitment; diff --git a/state/tests/test.rs b/state/tests/test.rs deleted file mode 100644 index 9666a7e12f..0000000000 --- a/state/tests/test.rs +++ /dev/null @@ -1,316 +0,0 @@ -use snarkos_curves::edwards_bls12::{EdwardsParameters, EdwardsProjective as EdwardsBls}; -use snarkos_dpc::base_dpc::{ - instantiated::*, - record_encryption::*, - record_payload::RecordPayload, - record_serializer::*, - BaseDPCComponents, - ExecuteContext, - DPC, -}; -use snarkos_models::{ - algorithms::{CommitmentScheme, CRH}, - dpc::{Record, RecordSerializerScheme}, - objects::AccountScheme, -}; -use snarkos_objects::{ - Account, - AccountViewKey, - Block, - BlockHeader, - BlockHeaderHash, - DPCTransactions, - MerkleRootHash, - PedersenMerkleRootHash, - ProofOfSuccinctWork, -}; -use snarkos_utilities::{bytes::ToBytes, rand::UniformRand, to_bytes}; - -use rand::{Rng, SeedableRng}; -use rand_xorshift::XorShiftRng; -use snarkos_algorithms::commitment_tree::CommitmentMerklePath; -use snarkos_dpc::{DummyProgram, NoopProgram}; -use snarkos_models::{ - algorithms::MerkleParameters, - dpc::{DPCScheme, Program}, - objects::LedgerScheme, -}; - -#[test] -fn test_integrate_with_dpc() { - use snarkos_testing::storage::*; - type L = Ledger; - - let mut rng = XorShiftRng::seed_from_u64(1231275789u64); - - // Specify network_id - let network_id: u8 = 0; - - // Generate parameters for the ledger, commitment schemes, CRH, and the - // "always-accept" program. - let ledger_parameters = CommitmentMerkleParameters::setup(&mut rng); - let system_parameters = InstantiatedDPC::generate_system_parameters(&mut rng).unwrap(); - let noop_program_snark_pp = - InstantiatedDPC::generate_noop_program_snark_parameters(&system_parameters, &mut rng).unwrap(); - let dummy_program_snark_pp = - InstantiatedDPC::generate_dummy_program_snark_parameters(&system_parameters, &mut rng).unwrap(); - - let noop_program_id = to_bytes![ - ProgramVerificationKeyHash::hash( - &system_parameters.program_verification_key_hash, - &to_bytes![noop_program_snark_pp.verification_key].unwrap() - ) - .unwrap() - ] - .unwrap(); - - let dummy_program_id = to_bytes![ - ProgramVerificationKeyHash::hash( - &system_parameters.program_verification_key_hash, - &to_bytes![dummy_program_snark_pp.verification_key].unwrap() - ) - .unwrap() - ] - .unwrap(); - - let signature_parameters = &system_parameters.account_signature; - let commitment_parameters = &system_parameters.account_commitment; - let encryption_parameters = &system_parameters.account_encryption; - - // Generate metadata and an account for a dummy initial record. - let dummy_account = Account::new( - signature_parameters, - commitment_parameters, - encryption_parameters, - &mut rng, - ) - .unwrap(); - - let genesis_block = Block { - header: BlockHeader { - previous_block_hash: BlockHeaderHash([0u8; 32]), - merkle_root_hash: MerkleRootHash([0u8; 32]), - time: 0, - difficulty_target: 0x07FF_FFFF_FFFF_FFFF_u64, - nonce: 0, - pedersen_merkle_root_hash: PedersenMerkleRootHash([0u8; 32]), - proof: ProofOfSuccinctWork::default(), - }, - transactions: DPCTransactions::new(), - }; - - // Use genesis record, serial number, and memo to initialize the ledger. - let ledger = initialize_test_blockchain::(ledger_parameters, genesis_block); - - let sn_nonce = SerialNumberNonce::hash(&system_parameters.serial_number_nonce, &[0u8; 1]).unwrap(); - // let old_record = DPC::generate_record( - // &system_parameters, - // &sn_nonce, - // &dummy_account.address, - // true, - // 0, - // &RecordPayload::default(), - // &dummy_program_id, - // &dummy_program_id, - // &mut rng, - // ) - // .unwrap(); - - let value = rng.gen(); - let payload: [u8; 32] = rng.gen(); - let old_record = DPC::generate_record( - &system_parameters, - &sn_nonce, - &dummy_account.address, - false, - value, - &RecordPayload::from_bytes(&payload), - &noop_program_id, - &noop_program_id, - &mut rng, - ) - .unwrap(); - - // Set the input records for our transaction to be the initial dummy records. - let old_records = vec![old_record.clone(); NUM_INPUT_RECORDS]; - let old_account_private_keys = vec![dummy_account.private_key.clone(); NUM_INPUT_RECORDS]; - - // Construct new records. - - // Create an account for an actual new record. - - let new_account = Account::new( - signature_parameters, - commitment_parameters, - encryption_parameters, - &mut rng, - ) - .unwrap(); - - // Set the new record's program to be the "always-accept" program. - - let new_record_owners = vec![new_account.address.clone(); NUM_OUTPUT_RECORDS]; - let new_is_dummy_flags = vec![false; NUM_OUTPUT_RECORDS]; - let new_values = vec![10; NUM_OUTPUT_RECORDS]; - let new_payloads = vec![RecordPayload::default(); NUM_OUTPUT_RECORDS]; - let new_birth_program_ids = vec![noop_program_id.clone(); NUM_OUTPUT_RECORDS]; - let new_death_program_ids = vec![noop_program_id.clone(); NUM_OUTPUT_RECORDS]; - let memo = [0u8; 32]; - - let context = >::execute_offline( - &system_parameters, - &old_records, - &old_account_private_keys, - &new_record_owners, - &new_is_dummy_flags, - &new_values, - &new_payloads, - &new_birth_program_ids, - &new_death_program_ids, - &memo, - network_id, - &mut rng, - ) - .unwrap(); - - let local_data = context.into_local_data(); - - for (i, record) in local_data.old_records.iter().enumerate() { - println!("{} : {}", i, record.is_dummy()); - } - - ////////////////////////////////////////////////////////////// - // Todo: parse state from file instead of DPC::generate_record - // compare commitments - /* - let commitment = Commit( - record.owner, - record.value, - record.payload, - record.is_dummy, - record.birth_program_id, - record.death_program_id, - record.serial_number_nonce, - record.commitment_randomness, - ); - - record.commitment == commitment - */ - - let record_commitment_input = to_bytes![ - old_record.owner(), - old_record.is_dummy(), - old_record.value(), - old_record.payload(), - old_record.birth_program_id(), - old_record.death_program_id(), - old_record.serial_number_nonce() - ] - .unwrap(); - - let record_commitment = RecordCommitment::commit( - &system_parameters.record_commitment, - &record_commitment_input, - &old_record.commitment_randomness(), - ) - .unwrap(); - - assert_eq!(record_commitment, old_record.commitment()); - - ////////////////////////////////////////////////////////////// - - // Verify local data commitment - - // let leaf_index = 0; - // let root = local_data.local_data_merkle_tree.root(); - // - // let path = ledger.prove_cm(&old_record.commitment()).unwrap(); - // let memo = local_data.memorandum; - // let network_id = local_data.network_id; - // let leaf_randomness = local_data.local_data_commitment_randomizers[0].clone(); - - // Verify that the local data commitment leaf is valid for the root - - // let path = ledger.prove_cm(&record.commitment()).unwrap(); - // let digest = ledger.digest().unwrap(); - // let verified = path.verify(&digest, &record.commitment()).unwrap(); - - ///////////////////////////////////////////////// - - // Generate the program proofs - - // let noop_program = NoopProgram::<_, ::NoopProgramSNARK>::new(noop_program_id); - // let dummy_program = DummyProgram::<_, ::DummyProgramSNARK>::new(dummy_program_id); - // - // let mut old_proof_and_vk = vec![]; - // for i in 0..NUM_INPUT_RECORDS { - // let private_input = dummy_program - // .execute( - // &dummy_program_snark_pp.proving_key, - // &dummy_program_snark_pp.verification_key, - // &local_data, - // i as u8, - // &mut rng, - // ) - // .unwrap(); - // - // old_proof_and_vk.push(private_input); - // } - // - // let mut new_proof_and_vk = vec![]; - // for j in 0..NUM_OUTPUT_RECORDS { - // let private_input = noop_program - // .execute( - // &noop_program_snark_pp.proving_key, - // &noop_program_snark_pp.verification_key, - // &local_data, - // (NUM_INPUT_RECORDS + j) as u8, - // &mut rng, - // ) - // .unwrap(); - // - // new_proof_and_vk.push(private_input); - // } - // - // let ExecuteContext { - // system_parameters: _, - // - // old_records, - // old_account_private_keys, - // old_serial_numbers, - // old_randomizers: _, - // - // new_records, - // new_sn_nonce_randomness, - // new_commitments, - // - // new_records_encryption_randomness, - // new_encrypted_records: _, - // new_encrypted_record_hashes, - // - // program_commitment, - // program_randomness, - // local_data_merkle_tree, - // local_data_commitment_randomizers, - // value_balance, - // memorandum, - // network_id, - // } = context; - // - // let local_data_root = local_data_merkle_tree.root(); - - // Verify that the local data commitment leaf is valid for the root - - // let local_data_commitment = LocalDataCommitment::commit( - // &system_parameters.local_data_commitment, - // - // ) - - // let merkle = CommitmentMerklePath::verify( - // system_parameters.local_data_commitment - // state.root - // state.path - // ) - - // system_parameters.local_data_commitment -} diff --git a/state/tests/test_verify_local_data_commitment.rs b/state/tests/test_verify_local_data_commitment.rs new file mode 100644 index 0000000000..43a530cb1d --- /dev/null +++ b/state/tests/test_verify_local_data_commitment.rs @@ -0,0 +1,204 @@ +use leo_input::LeoInputParser; +use leo_state::verify_local_data_commitment; +use leo_typed::Input; + +use snarkos_dpc::base_dpc::{instantiated::*, record_payload::RecordPayload, DPC}; +use snarkos_models::{ + algorithms::{CommitmentScheme, CRH}, + dpc::Record, + objects::AccountScheme, +}; +use snarkos_objects::Account; +use snarkos_utilities::{bytes::ToBytes, to_bytes}; + +use rand::{Rng, SeedableRng}; +use rand_xorshift::XorShiftRng; +use snarkos_models::dpc::DPCScheme; + +#[test] +fn test_integrate_with_dpc() { + use snarkos_testing::storage::*; + type L = Ledger; + + let mut rng = XorShiftRng::seed_from_u64(1231275789u64); + + // Specify network_id + let network_id: u8 = 0; + + // Generate parameters for the ledger, commitment schemes, CRH, and the + // "always-accept" program. + let system_parameters = InstantiatedDPC::generate_system_parameters(&mut rng).unwrap(); + let noop_program_snark_pp = + InstantiatedDPC::generate_noop_program_snark_parameters(&system_parameters, &mut rng).unwrap(); + + let noop_program_id = to_bytes![ + ProgramVerificationKeyHash::hash( + &system_parameters.program_verification_key_hash, + &to_bytes![noop_program_snark_pp.verification_key].unwrap() + ) + .unwrap() + ] + .unwrap(); + + let signature_parameters = &system_parameters.account_signature; + let commitment_parameters = &system_parameters.account_commitment; + let encryption_parameters = &system_parameters.account_encryption; + + // Generate metadata and an account for a dummy initial record. + let dummy_account = Account::new( + signature_parameters, + commitment_parameters, + encryption_parameters, + &mut rng, + ) + .unwrap(); + + let sn_nonce = SerialNumberNonce::hash(&system_parameters.serial_number_nonce, &[0u8; 1]).unwrap(); + let value = rng.gen(); + let payload: [u8; 32] = rng.gen(); + + let old_record = DPC::generate_record( + &system_parameters, + &sn_nonce, + &dummy_account.address, + false, + value, + &RecordPayload::from_bytes(&payload), + &noop_program_id, + &noop_program_id, + &mut rng, + ) + .unwrap(); + + // Set the input records for our transaction to be the initial dummy records. + let old_records = vec![old_record.clone(); NUM_INPUT_RECORDS]; + let old_account_private_keys = vec![dummy_account.private_key.clone(); NUM_INPUT_RECORDS]; + + // Construct new records. + + // Create an account for an actual new record. + + let new_account = Account::new( + signature_parameters, + commitment_parameters, + encryption_parameters, + &mut rng, + ) + .unwrap(); + + // Set the new record's program to be the "always-accept" program. + + let new_record_owners = vec![new_account.address.clone(); NUM_OUTPUT_RECORDS]; + let new_is_dummy_flags = vec![false; NUM_OUTPUT_RECORDS]; + let new_values = vec![10; NUM_OUTPUT_RECORDS]; + let new_payloads = vec![RecordPayload::default(); NUM_OUTPUT_RECORDS]; + let new_birth_program_ids = vec![noop_program_id.clone(); NUM_OUTPUT_RECORDS]; + let new_death_program_ids = vec![noop_program_id.clone(); NUM_OUTPUT_RECORDS]; + let memo = [0u8; 32]; + + let context = >::execute_offline( + &system_parameters, + &old_records, + &old_account_private_keys, + &new_record_owners, + &new_is_dummy_flags, + &new_values, + &new_payloads, + &new_birth_program_ids, + &new_death_program_ids, + &memo, + network_id, + &mut rng, + ) + .unwrap(); + let local_data = context.into_local_data(); + let leaf_index = 0; + let record = &local_data.old_records[leaf_index]; + + let root = local_data.local_data_merkle_tree.root(); + + let serial_number = local_data.old_serial_numbers[0].clone(); + let serial_number_bytes = to_bytes![serial_number].unwrap(); + + let memorandum = local_data.memorandum; + let network_id = local_data.network_id; + let input_bytes = to_bytes![serial_number, record.commitment(), memorandum, network_id].unwrap(); + let leaf_randomness = local_data.local_data_commitment_randomizers[0].clone(); + + let old_record_leaf = ::commit( + &system_parameters.local_data_commitment, + &input_bytes, + &leaf_randomness, + ) + .unwrap(); + + // generate the path + + let path = local_data + .local_data_merkle_tree + .generate_proof(&old_record_leaf) + .unwrap(); + + println!("////////////////////////////////////////////////////"); + println!(); + println!("[state]"); + println!("leaf index {}", leaf_index); + println!("root {:?}", to_bytes![root].unwrap()); + println!(); + println!("[record]"); + println!( + "serial number {:?} len {}", + serial_number_bytes, + serial_number_bytes.len() + ); + println!("commitment {:?}", to_bytes![record.commitment()].unwrap()); + println!("owner {}", record.owner()); + println!("is_dummy {:?}", record.is_dummy()); + println!("value {:?}", record.value()); + println!("payload {:?}", record.payload()); + println!("birth_program_id {:?}", record.birth_program_id()); + println!("death_program_id {:?}", record.death_program_id()); + println!( + "serial number nonce {:?}", + to_bytes![record.serial_number_nonce()].unwrap() + ); + println!( + "commitment randomness {:?}", + to_bytes![record.commitment_randomness()].unwrap() + ); + println!(); + println!("[state_leaf]"); + println!("path {:?}", to_bytes![path].unwrap()); + println!("memo {:?}", memorandum); + println!("network id {:?}", network_id); + println!("leaf randomness {:?}", to_bytes![leaf_randomness].unwrap()); + println!(); + println!("////////////////////////////////////////////////////"); +} + +#[test] +fn test_verify_local_data_commitment_from_file() { + let mut rng = XorShiftRng::seed_from_u64(1231275789u64); + + // Generate parameters for the record commitment scheme + let system_parameters = InstantiatedDPC::generate_system_parameters(&mut rng).unwrap(); + + // Load test record state file from `inputs/test.state` + let file_bytes = include_bytes!("inputs/test_state.state"); + let file_string = String::from_utf8_lossy(file_bytes); + let file = LeoInputParser::parse_file(&file_string).unwrap(); + + let mut program_input = Input::new(); + program_input.parse_state(file).unwrap(); + + // check record state is correct by verifying commitment + let result = verify_local_data_commitment( + &program_input, + system_parameters.record_commitment, + system_parameters.local_data_commitment, + system_parameters.local_data_crh, + ) + .unwrap(); + + assert!(result); +} diff --git a/state/tests/test_verify_record_commitment.rs b/state/tests/test_verify_record_commitment.rs index 6defe9e344..74cbfa708d 100644 --- a/state/tests/test_verify_record_commitment.rs +++ b/state/tests/test_verify_record_commitment.rs @@ -1,8 +1,9 @@ -use snarkos_dpc::base_dpc::instantiated::*; - use leo_input::LeoInputParser; use leo_state::verify_record_commitment; use leo_typed::Input; + +use snarkos_dpc::base_dpc::instantiated::*; + use rand::SeedableRng; use rand_xorshift::XorShiftRng; @@ -14,7 +15,7 @@ fn test_verify_record_from_file() { let system_parameters = InstantiatedDPC::generate_system_parameters(&mut rng).unwrap(); // Load test record state file from `inputs/test.state` - let file_bytes = include_bytes!("inputs/test.state"); + let file_bytes = include_bytes!("inputs/test_record.state"); let file_string = String::from_utf8_lossy(file_bytes); let file = LeoInputParser::parse_file(&file_string).unwrap();