mirror of
https://github.com/AleoHQ/leo.git
synced 2024-09-22 04:27:25 +03:00
add verify_local_data_commitment test
This commit is contained in:
parent
61bafc96a9
commit
4f3722033a
@ -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<Vec<u8>> = state_leaf_values.path;
|
||||
let path: Vec<u8> = state_leaf_values.path;
|
||||
let memo: Vec<u8> = state_leaf_values.memo;
|
||||
let network_id: u8 = state_leaf_values.network_id;
|
||||
let leaf_randomness: Vec<u8> = 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 = <LocalDataCommitment as CommitmentScheme>::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 = (
|
||||
<LocalDataCommitment as CommitmentScheme>::Output::default(),
|
||||
<LocalDataCommitment as CommitmentScheme>::Output::default(),
|
||||
);
|
||||
|
||||
let inner_hashes = (
|
||||
<LocalDataCRH as CRH>::Output::default(),
|
||||
<LocalDataCRH as CRH>::Output::default(),
|
||||
);
|
||||
|
||||
let local_data_merkle_path = CommitmentMerklePath::<LocalDataCommitment, LocalDataCRH> {
|
||||
leaves,
|
||||
inner_hashes,
|
||||
parameters: local_data_crh_params,
|
||||
};
|
||||
let mut local_data_merkle_path = CommitmentMerklePath::<LocalDataCommitment, LocalDataCRH>::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 = <LocalDataCRH as CRH>::Output::read(&root[..])?;
|
||||
let result = local_data_merkle_path.verify(&local_data_commitment_root, &local_data_commitment_leaf)?;
|
||||
|
||||
Ok(result)
|
||||
|
@ -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<Vec<u8>>,
|
||||
pub path: Vec<u8>,
|
||||
pub memo: Vec<u8>,
|
||||
pub network_id: u8,
|
||||
pub leaf_randomness: Vec<u8>,
|
||||
@ -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)?;
|
||||
|
@ -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,
|
||||
|
@ -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];
|
23
state/tests/inputs/test_state.state
Normal file
23
state/tests/inputs/test_state.state
Normal file
@ -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];
|
@ -1,3 +1,3 @@
|
||||
// mod test;
|
||||
mod test_verify_local_data_commitment;
|
||||
|
||||
mod test_verify_record_commitment;
|
||||
|
@ -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<Tx, CommitmentMerkleParameters>;
|
||||
|
||||
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::<Tx, CommitmentMerkleParameters>(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 = <InstantiatedDPC as DPCScheme<L>>::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::<_, <Components as BaseDPCComponents>::NoopProgramSNARK>::new(noop_program_id);
|
||||
// let dummy_program = DummyProgram::<_, <Components as BaseDPCComponents>::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
|
||||
}
|
204
state/tests/test_verify_local_data_commitment.rs
Normal file
204
state/tests/test_verify_local_data_commitment.rs
Normal file
@ -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<Tx, CommitmentMerkleParameters>;
|
||||
|
||||
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 = <InstantiatedDPC as DPCScheme<L>>::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 = <LocalDataCommitment as CommitmentScheme>::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);
|
||||
}
|
@ -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();
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user