Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Sync with resource machine #251

Merged
merged 12 commits into from
Nov 24, 2023
Merged

Sync with resource machine #251

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
12 commits
Select commit Hold shift + click to select a range
eb6f3c8
rename note to resource everywhere
XuyangSong Nov 21, 2023
c1baa5a
rename note commitment to resource commitment
XuyangSong Nov 21, 2023
b8dfea2
rename note encryption to resource encryption
XuyangSong Nov 21, 2023
21da44c
rename note type to resource kind
XuyangSong Nov 21, 2023
f40716b
rename value to quantity
XuyangSong Nov 22, 2023
b2067c5
rename value_commitment to delta_commitment, cv_net to delta
XuyangSong Nov 23, 2023
6410cc6
rename app_vk to logic
XuyangSong Nov 23, 2023
6ebafc9
rename app_data_static to label
XuyangSong Nov 23, 2023
1511c01
rename app_data_dynamic to value
XuyangSong Nov 23, 2023
e236703
rename nonce in resource encryption to encrypt_nonce
XuyangSong Nov 23, 2023
060ea08
rename rho to nonce
XuyangSong Nov 23, 2023
ad23872
rename nullifier key commitment to nullifier public key
XuyangSong Nov 23, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
66 changes: 33 additions & 33 deletions taiga_halo2/benches/action_proof.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -14,63 +14,63 @@ use taiga_halo2::{
TAIGA_COMMITMENT_TREE_DEPTH,
},
merkle_tree::MerklePath,
note::{Note, NoteType, RandomSeed},
nullifier::{Nullifier, NullifierKeyContainer},
resource::{RandomSeed, Resource, ResourceKind},
};

fn bench_action_proof(name: &str, c: &mut Criterion) {
let mut rng = OsRng;
let action_info = {
let input_note = {
let rho = Nullifier::from(pallas::Base::random(&mut rng));
let input_resource = {
let nonce = Nullifier::from(pallas::Base::random(&mut rng));
let nk = NullifierKeyContainer::from_key(pallas::Base::random(&mut rng));
let note_type = {
let app_vk = pallas::Base::random(&mut rng);
let app_data_static = pallas::Base::random(&mut rng);
NoteType::new(app_vk, app_data_static)
let kind = {
let logic = pallas::Base::random(&mut rng);
let label = pallas::Base::random(&mut rng);
ResourceKind::new(logic, label)
};
let app_data_dynamic = pallas::Base::random(&mut rng);
let value: u64 = rng.gen();
let value = pallas::Base::random(&mut rng);
let quantity: u64 = rng.gen();
let rseed = RandomSeed::random(&mut rng);
Note {
note_type,
app_data_dynamic,
Resource {
kind,
value,
quantity,
nk_container: nk,
is_merkle_checked: true,
psi: rseed.get_psi(&rho),
rcm: rseed.get_rcm(&rho),
rho,
psi: rseed.get_psi(&nonce),
rcm: rseed.get_rcm(&nonce),
nonce,
}
};
let mut output_note = {
let rho = input_note.get_nf().unwrap();
let nk_com = NullifierKeyContainer::from_commitment(pallas::Base::random(&mut rng));
let note_type = {
let app_vk = pallas::Base::random(&mut rng);
let app_data_static = pallas::Base::random(&mut rng);
NoteType::new(app_vk, app_data_static)
let mut output_resource = {
let nonce = input_resource.get_nf().unwrap();
let npk = NullifierKeyContainer::from_npk(pallas::Base::random(&mut rng));
let kind = {
let logic = pallas::Base::random(&mut rng);
let label = pallas::Base::random(&mut rng);
ResourceKind::new(logic, label)
};
let app_data_dynamic = pallas::Base::random(&mut rng);
let value: u64 = rng.gen();
let value = pallas::Base::random(&mut rng);
let quantity: u64 = rng.gen();
let rseed = RandomSeed::random(&mut rng);
Note {
note_type,
app_data_dynamic,
Resource {
kind,
value,
nk_container: nk_com,
quantity,
nk_container: npk,
is_merkle_checked: true,
psi: rseed.get_psi(&rho),
rcm: rseed.get_rcm(&rho),
rho,
psi: rseed.get_psi(&nonce),
rcm: rseed.get_rcm(&nonce),
nonce,
}
};
let input_merkle_path = MerklePath::random(&mut rng, TAIGA_COMMITMENT_TREE_DEPTH);
ActionInfo::new(
input_note,
input_resource,
input_merkle_path,
None,
&mut output_note,
&mut output_resource,
&mut rng,
)
};
Expand Down
72 changes: 36 additions & 36 deletions taiga_halo2/benches/vp_proof.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -7,68 +7,68 @@ use rand::rngs::OsRng;
use rand::Rng;
use taiga_halo2::{
circuit::{vp_circuit::ValidityPredicateCircuit, vp_examples::TrivialValidityPredicateCircuit},
constant::{NUM_NOTE, SETUP_PARAMS_MAP, VP_CIRCUIT_PARAMS_SIZE},
note::{Note, NoteType, RandomSeed},
constant::{NUM_RESOURCE, SETUP_PARAMS_MAP, VP_CIRCUIT_PARAMS_SIZE},
nullifier::{Nullifier, NullifierKeyContainer},
proof::Proof,
resource::{RandomSeed, Resource, ResourceKind},
};

fn bench_vp_proof(name: &str, c: &mut Criterion) {
let mut rng = OsRng;

let vp_circuit = {
let input_notes = [(); NUM_NOTE].map(|_| {
let rho = Nullifier::from(pallas::Base::random(&mut rng));
let input_resources = [(); NUM_RESOURCE].map(|_| {
let nonce = Nullifier::from(pallas::Base::random(&mut rng));
let nk = NullifierKeyContainer::from_key(pallas::Base::random(&mut rng));
let note_type = {
let app_vk = pallas::Base::random(&mut rng);
let app_data_static = pallas::Base::random(&mut rng);
NoteType::new(app_vk, app_data_static)
let kind = {
let logic = pallas::Base::random(&mut rng);
let label = pallas::Base::random(&mut rng);
ResourceKind::new(logic, label)
};
let app_data_dynamic = pallas::Base::random(&mut rng);
let value: u64 = rng.gen();
let value = pallas::Base::random(&mut rng);
let quantity: u64 = rng.gen();
let rseed = RandomSeed::random(&mut rng);
Note {
note_type,
app_data_dynamic,
Resource {
kind,
value,
quantity,
nk_container: nk,
is_merkle_checked: true,
psi: rseed.get_psi(&rho),
rcm: rseed.get_rcm(&rho),
rho,
psi: rseed.get_psi(&nonce),
rcm: rseed.get_rcm(&nonce),
nonce,
}
});
let output_notes = input_notes
let output_resources = input_resources
.iter()
.map(|input| {
let rho = input.get_nf().unwrap();
let nk_com = NullifierKeyContainer::from_commitment(pallas::Base::random(&mut rng));
let note_type = {
let app_vk = pallas::Base::random(&mut rng);
let app_data_static = pallas::Base::random(&mut rng);
NoteType::new(app_vk, app_data_static)
let nonce = input.get_nf().unwrap();
let npk = NullifierKeyContainer::from_npk(pallas::Base::random(&mut rng));
let kind = {
let logic = pallas::Base::random(&mut rng);
let label = pallas::Base::random(&mut rng);
ResourceKind::new(logic, label)
};
let app_data_dynamic = pallas::Base::random(&mut rng);
let value: u64 = rng.gen();
let value = pallas::Base::random(&mut rng);
let quantity: u64 = rng.gen();
let rseed = RandomSeed::random(&mut rng);
Note {
note_type,
app_data_dynamic,
Resource {
kind,
value,
nk_container: nk_com,
quantity,
nk_container: npk,
is_merkle_checked: true,
psi: rseed.get_psi(&rho),
rcm: rseed.get_rcm(&rho),
rho,
psi: rseed.get_psi(&nonce),
rcm: rseed.get_rcm(&nonce),
nonce,
}
})
.collect::<Vec<_>>();
let owned_note_pub_id = input_notes[0].get_nf().unwrap().inner();
let owned_resource_id = input_resources[0].get_nf().unwrap().inner();
TrivialValidityPredicateCircuit::new(
owned_note_pub_id,
input_notes,
output_notes.try_into().unwrap(),
owned_resource_id,
input_resources,
output_resources.try_into().unwrap(),
)
};
let params = SETUP_PARAMS_MAP.get(&VP_CIRCUIT_PARAMS_SIZE).unwrap();
Expand Down
46 changes: 23 additions & 23 deletions taiga_halo2/deprecated/simple_sudoku/vp.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -7,15 +7,15 @@ use pasta_curves::pallas;
extern crate taiga_halo2;
use taiga_halo2::{
circuit::{
note_circuit::NoteConfig,
resource_circuit::ResourceConfig,
vp_circuit::{
BasicValidityPredicateVariables, VPVerifyingInfo, ValidityPredicateCircuit,
ValidityPredicateConfig, ValidityPredicateInfo, ValidityPredicatePublicInputs,
ValidityPredicateVerifyingInfo,
},
},
constant::{NUM_NOTE, SETUP_PARAMS_MAP},
note::{Note, RandomSeed},
constant::{NUM_RESOURCE, SETUP_PARAMS_MAP},
resource::{Resource, RandomSeed},
proof::Proof,
vp_circuit_impl,
vp_vk::ValidityPredicateVerifyingKey,
Expand All @@ -26,15 +26,15 @@ use rand::{rngs::OsRng, RngCore};

#[derive(Clone, Debug)]
pub struct SudokuVPConfig {
note_config: NoteConfig,
resource_config: ResourceConfig,
sudoku_config: SudokuConfig,
}

#[derive(Clone, Debug, Default)]
pub struct SudokuVP {
pub sudoku: SudokuCircuit,
input_notes: [Note; NUM_NOTE],
output_notes: [Note; NUM_NOTE],
input_resources: [Resource; NUM_RESOURCE],
output_resources: [Resource; NUM_RESOURCE],
}

impl ValidityPredicateCircuit for SudokuVP {
Expand All @@ -49,12 +49,12 @@ impl ValidityPredicateCircuit for SudokuVP {
}

impl ValidityPredicateInfo for SudokuVP {
fn get_input_notes(&self) -> &[Note; NUM_NOTE] {
&self.input_notes
fn get_input_resources(&self) -> &[Resource; NUM_RESOURCE] {
&self.input_resources
}

fn get_output_notes(&self) -> &[Note; NUM_NOTE] {
&self.output_notes
fn get_output_resources(&self) -> &[Resource; NUM_RESOURCE] {
&self.output_resources
}

fn get_public_inputs(&self, mut rng: impl RngCore) -> ValidityPredicatePublicInputs {
Expand All @@ -67,21 +67,21 @@ impl ValidityPredicateInfo for SudokuVP {
public_inputs.into()
}

fn get_owned_note_pub_id(&self) -> pallas::Base {
fn get_owned_resource_id(&self) -> pallas::Base {
pallas::Base::zero()
}
}

impl SudokuVP {
pub fn new(
sudoku: SudokuCircuit,
input_notes: [Note; NUM_NOTE],
output_notes: [Note; NUM_NOTE],
input_resources: [Resource; NUM_RESOURCE],
output_resources: [Resource; NUM_RESOURCE],
) -> Self {
Self {
sudoku,
input_notes,
output_notes,
input_resources,
output_resources,
}
}
}
Expand All @@ -91,8 +91,8 @@ vp_circuit_impl!(SudokuVP);
#[cfg(test)]
mod tests {
use taiga_halo2::{
constant::NUM_NOTE,
note::{Note, RandomSeed},
constant::NUM_RESOURCE,
resource::{Resource, RandomSeed},
nullifier::{Nullifier, NullifierKeyContainer},
vp_vk::ValidityPredicateVerifyingKey,
};
Expand All @@ -108,8 +108,8 @@ mod tests {
#[test]
fn test_vp() {
let mut rng = OsRng;
let input_notes = [(); NUM_NOTE].map(|_| Note::dummy(&mut rng));
let output_notes = [(); NUM_NOTE].map(|_| Note::dummy(&mut rng));
let input_resources = [(); NUM_RESOURCE].map(|_| Resource::dummy(&mut rng));
let output_resources = [(); NUM_RESOURCE].map(|_| Resource::dummy(&mut rng));

const K: u32 = 13;
let sudoku = SudokuCircuit {
Expand All @@ -129,22 +129,22 @@ mod tests {

let vk = plonk::keygen_vk(&params, &sudoku).unwrap();

let mut _vp = SudokuVP::new(sudoku, input_notes, output_notes);
let mut _vp = SudokuVP::new(sudoku, input_resources, output_resources);

let vp_vk = ValidityPredicateVerifyingKey::from_vk(vk);

let app_data_static = pallas::Base::zero();
let app_data_dynamic = pallas::Base::zero();

let value: u64 = 0;
let quantity: u64 = 0;
let nk = NullifierKeyContainer::random_key(&mut rng);
let rseed = RandomSeed::random(&mut rng);
let rho = Nullifier::from(pallas::Base::random(&mut rng));
Note::new(
Resource::new(
vp_vk,
app_data_static,
app_data_dynamic,
value,
quantity,
nk,
rho,
true,
Expand Down
Loading
Loading