github/darkfi
1
1
Fork 0
mirror of https://github.com/darkrenaissance/darkfi.git synced 2026-01-08 22:28:12 -05:00
Code Issues Packages Projects Releases Wiki Activity

Clean up proof and testdata directories and move into tests dir.

Browse Source
This commit is contained in:
parazyd
2022-03-17 00:49:13 +01:00
parent 358683765e
commit e7d968dfd7
11 changed files with 26 additions and 303 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
.gitignore vendored
View File

@@ -5,12 +5,15 @@
/target/*
/proof/*.bin
/zkas
/drk
/darkfid
/cashierd
/dao-cli
/daod
/darkfid
/dnetview
/drk
/gatewayd
/ircd
/map
/tau-cli
/taud
/vanityaddr
/dnetview
/zkas

17
Cargo.toml
View File

@@ -251,20 +251,3 @@ required-features = ["node"]
name = "dao-process"
path = "example/dao_process.rs"
required-features = ["crypto", "zkas"]
# ZK VM Proof examples
[[example]]
name = "arithmetic"
path = "proof/arithmetic.rs"
required-features = ["crypto", "zkas"]
[[example]]
name = "mint"
path = "proof/mint.rs"
required-features = ["crypto", "zkas"]
[[example]]
name = "burn"
path = "proof/burn.rs"
required-features = ["crypto", "zkas"]

18
Makefile
View File

@@ -33,22 +33,18 @@ fix:
clippy:
$(CARGO) clippy --release --all-features --all
test: test-vm test-tx
$(CARGO) test --release --all-features --all
test-tx:
$(CARGO) run --release --features=node,zkas --example tx
# zkas source files which we want to compile for tests
VM_SRC = proof/arithmetic.zk proof/mint.zk proof/burn.zk
VM_BIN = $(VM_SRC:=.bin)
$(VM_BIN): zkas $(VM_SRC)
./zkas $(basename $@) -o $@
test-vm: $(VM_BIN)
$(CARGO) run --release --features=crypto,zkas --example arithmetic
$(CARGO) run --release --features=crypto,zkas --example mint
$(CARGO) run --release --features=crypto,zkas --example burn
test: $(VM_BIN) test-tx
$(CARGO) test --release --all-features --all
test-tx:
$(CARGO) run --release --features=node,zkas --example tx
clean:
rm -f $(BINS)
@@ -63,4 +59,4 @@ uninstall:
rm -f $(DESTDIR)$(PREFIX)/bin/$$i; \
done;
.PHONY: all check fix clippy test test-tx test-vm clean install uninstall
.PHONY: all check fix clippy test test-tx clean install uninstall

161
proof/dao.rs
View File

@@ -1,161 +0,0 @@
use halo2_gadgets::primitives::{
poseidon,
poseidon::{ConstantLength, P128Pow5T3},
};
use halo2_proofs::dev::MockProver;
use incrementalmerkletree::{bridgetree::BridgeTree, Frontier, Tree};
use pasta_curves::{
arithmetic::CurveAffine,
group::{
ff::{Field, PrimeField},
Curve, Group,
},
pallas,
};
use rand::rngs::OsRng;
use simplelog::{ColorChoice::Auto, Config, LevelFilter, TermLogger, TerminalMode::Mixed};
use darkfi::{
crypto::{
keypair::Keypair,
merkle_node::MerkleNode,
schnorr::SchnorrSecret,
util::{mod_r_p, pedersen_commitment_scalar},
},
zk::vm::{Witness, ZkCircuit},
zkas::decoder::ZkBinary,
Result,
};
fn main() -> Result<()> {
let loglevel = match option_env!("RUST_LOG") {
Some("debug") => LevelFilter::Debug,
Some("trace") => LevelFilter::Trace,
Some(_) | None => LevelFilter::Info,
};
TermLogger::init(loglevel, Config::default(), Mixed, Auto)?;
let bincode = include_bytes!("dao.zk.bin");
let zkbin = ZkBinary::decode(bincode)?;
// =============
// Initial state
// =============
let authority = Keypair::random(&mut OsRng);
let spend_contract = pallas::Base::random(&mut OsRng);
let cur_balance = pallas::Base::from(666);
let old_serial = pallas::Base::random(&mut OsRng);
let old_bulla_blind = pallas::Base::random(&mut OsRng);
let message = [spend_contract, cur_balance, old_serial, old_bulla_blind];
let hasher = poseidon::Hash::<_, P128Pow5T3, ConstantLength<4>, 3, 2>::init();
let our_dao = hasher.hash(message);
// Merkle tree of DAOs
let mut tree = BridgeTree::<MerkleNode, 32>::new(100);
let dao0 = pallas::Base::random(&mut OsRng);
let dao2 = pallas::Base::random(&mut OsRng);
tree.append(&MerkleNode(dao0));
tree.witness();
tree.append(&MerkleNode(our_dao));
tree.witness();
tree.append(&MerkleNode(dao2));
tree.witness();
// ========
// Proposal
// ========
let amount_to_send = pallas::Base::from(42);
let proposal_destination = pallas::Point::random(&mut OsRng);
let proposal_coords = proposal_destination.to_affine().coordinates().unwrap();
let proposal_blind = pallas::Base::random(&mut OsRng);
let message = [amount_to_send, *proposal_coords.x(), *proposal_coords.y(), proposal_blind];
let hasher = poseidon::Hash::<_, P128Pow5T3, ConstantLength<4>, 3, 2>::init();
let proposal = hasher.hash(message);
// Sign the proposal by the authority
let _signature = authority.secret.sign(&proposal.to_repr());
// ==============
// Voting process
// ==============
// The voting process happens now, and when finished, the votes are revealed.
// Votes are weighted by balance.
let vote0 = pallas::Base::from(44);
let vote0_blind = pallas::Scalar::random(&mut OsRng);
let vote1 = pallas::Base::from(13);
let vote1_blind = pallas::Scalar::random(&mut OsRng);
let vote2 = -pallas::Base::from(49); // This is a NO vote
let vote2_blind = pallas::Scalar::random(&mut OsRng);
let votes = vote0 + vote1 + vote2;
let vote_blinds = vote0_blind + vote1_blind + vote2_blind;
if votes < pallas::Base::from(1) {
// The voting process result is negative, so we don't do anything.
return Ok(())
}
// ==================
// Proof construction
// ==================
let (leaf_pos, merkle_path) = tree.authentication_path(&MerkleNode(our_dao)).unwrap();
let leaf_pos: u64 = leaf_pos.into();
let leaf_pos = leaf_pos as u32;
let new_serial = pallas::Base::random(&mut OsRng);
let new_bulla_blind = pallas::Base::random(&mut OsRng);
let new_balance = cur_balance - amount_to_send;
let message = [spend_contract, new_balance, new_serial, new_bulla_blind];
let hasher = poseidon::Hash::<_, P128Pow5T3, ConstantLength<4>, 3, 2>::init();
let new_bulla = hasher.hash(message);
let merkle_root = tree.root();
let value_blind = pallas::Scalar::random(&mut OsRng);
let value_commit = pedersen_commitment_scalar(mod_r_p(amount_to_send), value_blind);
let value_coords = value_commit.to_affine().coordinates().unwrap();
let public_inputs = vec![
spend_contract,
old_serial,
merkle_root.0,
proposal,
*value_coords.x(),
*value_coords.y(),
new_bulla,
];
let prover_witnesses = vec![
Witness::Base(Some(spend_contract)),
Witness::Base(Some(cur_balance)),
Witness::Base(Some(old_serial)),
Witness::Base(Some(old_bulla_blind)),
Witness::Uint32(Some(leaf_pos)),
Witness::MerklePath(Some(merkle_path.try_into().unwrap())),
Witness::Base(Some(amount_to_send)),
Witness::Base(Some(*proposal_coords.x())),
Witness::Base(Some(*proposal_coords.y())),
Witness::Base(Some(proposal_blind)),
Witness::Scalar(Some(value_blind)),
Witness::Base(Some(new_serial)),
Witness::Base(Some(new_bulla_blind)),
];
let circuit = ZkCircuit::new(prover_witnesses, zkbin.clone());
let prover = MockProver::<pallas::Base>::run(11, &circuit, vec![public_inputs])?;
assert_eq!(prover.verify(), Ok(()));
Ok(())
}

68
proof/dao.zk
View File

@@ -1,68 +0,0 @@
constant "DAO" {
EcFixedPointShort VALUE_COMMIT_VALUE,
EcFixedPoint VALUE_COMMIT_RANDOM,
}
contract "DAO" {
Base spend_contract,
Base cur_balance,
Base old_serial,
Base old_bulla_blind,
Uint32 leaf_pos,
MerklePath merkle_path,
Base amount_to_send,
Base pub_x,
Base pub_y,
Base proposal_blind,
Scalar proposal_value_blind,
Base new_serial,
Base new_bulla_blind,
}
circuit "DAO" {
# Enforce spend contract
constrain_instance(spend_contract);
# Reveal serial number
constrain_instance(old_serial);
# Poseidon hash of the current treasury
bulla = poseidon_hash(
spend_contract,
cur_balance,
old_serial,
old_bulla_blind,
);
# Enforce the merkle root
D = calculate_merkle_root(leaf_pos, merkle_path, bulla);
constrain_instance(D);
# Poseidon hash of the proposal (output 0)
proposal = poseidon_hash(amount_to_send, pub_x, pub_y, proposal_blind);
constrain_instance(proposal);
# Pedersen commitment to the amount we're sending
valc_v = ec_mul_short(amount_to_send, VALUE_COMMIT_VALUE);
valc_r = ec_mul(proposal_value_blind, VALUE_COMMIT_RANDOM);
value_commit = ec_add(valc_v, valc_r);
value_commit_x = ec_get_x(value_commit);
value_commit_y = ec_get_y(value_commit);
constrain_instance(value_commit_x);
constrain_instance(value_commit_y);
# Calculate remaining balance in treasury
new_balance = base_sub(cur_balance, amount_to_send);
# Poseidon hash of the new treasury
new_bulla = poseidon_hash(
spend_contract,
new_balance,
new_serial,
new_bulla_blind,
);
constrain_instance(new_bulla);
}

4
src/crypto/token_list.rs
View File

@@ -185,7 +185,7 @@ mod tests {
use super::*;
fn _get_sol_tokens() -> Result<TokenList> {
let file_contents = include_bytes!("../../testdata/solanatokenlisttest.json");
let file_contents = include_bytes!("../../tests/data/solanatokenlisttest.json");
let sol_tokenlist: Value = serde_json::from_slice(file_contents)?;
let tokens = sol_tokenlist["tokens"].as_array().ok_or(Error::TokenParseError)?.clone();
@@ -195,7 +195,7 @@ mod tests {
}
fn _get_eth_tokens() -> Result<TokenList> {
let file_contents = include_bytes!("../../testdata/erc20tokenlisttest.json");
let file_contents = include_bytes!("../../tests/data/erc20tokenlisttest.json");
let eth_tokenlist: Value = serde_json::from_slice(file_contents)?;
let tokens = eth_tokenlist["tokens"].as_array().ok_or(Error::TokenParseError)?.clone();

16
proof/arithmetic.rs → tests/arithmetic_proof.rs
View File

@@ -7,21 +7,13 @@ use darkfi::{
zkas::decoder::ZkBinary,
Result,
};
use log::info;
use pasta_curves::pallas;
use rand::rngs::OsRng;
use simplelog::{ColorChoice::Auto, Config, LevelFilter, TermLogger, TerminalMode::Mixed};
fn main() -> Result<()> {
let loglevel = match option_env!("RUST_LOG") {
Some("debug") => LevelFilter::Debug,
Some("trace") => LevelFilter::Trace,
Some(_) | None => LevelFilter::Info,
};
TermLogger::init(loglevel, Config::default(), Mixed, Auto)?;
#[test]
fn arithmetic_proof() -> Result<()> {
/* ANCHOR: main */
let bincode = include_bytes!("arithmetic.zk.bin");
let bincode = include_bytes!("../proof/arithmetic.zk.bin");
let zkbin = ZkBinary::decode(bincode)?;
// ======
@@ -44,7 +36,6 @@ fn main() -> Result<()> {
// Create the circuit
let circuit = ZkCircuit::new(prover_witnesses, zkbin.clone());
info!(target: "PROVER", "Building proving key and creating the zero-knowledge proof");
let proving_key = ProvingKey::build(11, &circuit);
let proof = Proof::create(&proving_key, &[circuit], &public_inputs, &mut OsRng)?;
@@ -58,7 +49,6 @@ fn main() -> Result<()> {
// Create the circuit
let circuit = ZkCircuit::new(verifier_witnesses, zkbin);
info!(target: "VERIFIER", "Building verifying key and verifying the zero-knowledge proof");
let verifying_key = VerifyingKey::build(11, &circuit);
proof.verify(&verifying_key, &public_inputs)?;
/* ANCHOR_END: main */

16
proof/burn.rs → tests/burn_proof.rs
View File

@@ -15,25 +15,17 @@ use halo2_gadgets::primitives::{
poseidon::{ConstantLength, P128Pow5T3},
};
use incrementalmerkletree::{bridgetree::BridgeTree, Frontier, Tree};
use log::info;
use pasta_curves::{
arithmetic::CurveAffine,
group::{ff::Field, Curve},
pallas,
};
use rand::rngs::OsRng;
use simplelog::{ColorChoice::Auto, Config, LevelFilter, TermLogger, TerminalMode::Mixed};
fn main() -> Result<()> {
let loglevel = match option_env!("RUST_LOG") {
Some("debug") => LevelFilter::Debug,
Some("trace") => LevelFilter::Trace,
Some(_) | None => LevelFilter::Info,
};
TermLogger::init(loglevel, Config::default(), Mixed, Auto)?;
#[test]
fn burn_proof() -> Result<()> {
/* ANCHOR: main */
let bincode = include_bytes!("burn.zk.bin");
let bincode = include_bytes!("../proof/burn.zk.bin");
let zkbin = ZkBinary::decode(bincode)?;
// ======
@@ -121,7 +113,6 @@ fn main() -> Result<()> {
// Create the circuit
let circuit = ZkCircuit::new(prover_witnesses, zkbin.clone());
info!(target: "PROVER", "Building proving key and creating the zero-knowledge proof");
let proving_key = ProvingKey::build(11, &circuit);
let proof = Proof::create(&proving_key, &[circuit], &public_inputs, &mut OsRng)?;
@@ -146,7 +137,6 @@ fn main() -> Result<()> {
// Create the circuit
let circuit = ZkCircuit::new(verifier_witnesses, zkbin);
info!(target: "VERIFIER", "Building verifying key and verifying the zero-knowledge proof");
let verifying_key = VerifyingKey::build(11, &circuit);
proof.verify(&verifying_key, &public_inputs)?;
/* ANCHOR_END: main */

0
testdata/erc20tokenlisttest.json → tests/data/erc20tokenlisttest.json
View File

0
testdata/solanatokenlisttest.json → tests/data/solanatokenlisttest.json
View File

16
proof/mint.rs → tests/mint_proof.rs
View File

@@ -13,25 +13,17 @@ use halo2_gadgets::primitives::{
poseidon,
poseidon::{ConstantLength, P128Pow5T3},
};
use log::info;
use pasta_curves::{
arithmetic::CurveAffine,
group::{ff::Field, Curve},
pallas,
};
use rand::rngs::OsRng;
use simplelog::{ColorChoice::Auto, Config, LevelFilter, TermLogger, TerminalMode::Mixed};
fn main() -> Result<()> {
let loglevel = match option_env!("RUST_LOG") {
Some("debug") => LevelFilter::Debug,
Some("trace") => LevelFilter::Trace,
Some(_) | None => LevelFilter::Info,
};
TermLogger::init(loglevel, Config::default(), Mixed, Auto)?;
#[test]
fn mint_proof() -> Result<()> {
/* ANCHOR: main */
let bincode = include_bytes!("mint.zk.bin");
let bincode = include_bytes!("../proof/mint.zk.bin");
let zkbin = ZkBinary::decode(bincode)?;
// ======
@@ -75,7 +67,6 @@ fn main() -> Result<()> {
// Create the circuit
let circuit = ZkCircuit::new(prover_witnesses, zkbin.clone());
info!(target: "PROVER", "Building proving key and creating the zero-knowledge proof");
let proving_key = ProvingKey::build(11, &circuit);
let proof = Proof::create(&proving_key, &[circuit], &public_inputs, &mut OsRng)?;
@@ -98,7 +89,6 @@ fn main() -> Result<()> {
// Create the circuit
let circuit = ZkCircuit::new(verifier_witnesses, zkbin);
info!(target: "VERIFIER", "Building verifying key and verifying the zero-knowledge proof");
let verifying_key = VerifyingKey::build(11, &circuit);
proof.verify(&verifying_key, &public_inputs)?;
/* ANCHOR_END: main */