From 05991cda50768abfa2b98342576d3f3cbc113166 Mon Sep 17 00:00:00 2001 From: parazyd Date: Thu, 20 Jul 2023 14:16:01 +0200 Subject: [PATCH] contract/test-harness: Use precompiled zk proving keys --- src/contract/test-harness/.gitignore | 1 + .../src/consensus_genesis_stake.rs | 4 +- .../test-harness/src/consensus_proposal.rs | 4 +- .../test-harness/src/consensus_stake.rs | 7 +- .../test-harness/src/consensus_unstake.rs | 9 +- .../src/consensus_unstake_request.rs | 6 +- src/contract/test-harness/src/dao_exec.rs | 12 +- src/contract/test-harness/src/dao_mint.rs | 6 +- src/contract/test-harness/src/dao_propose.rs | 8 +- src/contract/test-harness/src/dao_vote.rs | 8 +- src/contract/test-harness/src/lib.rs | 105 ++++-------------- .../test-harness/src/money_airdrop.rs | 6 +- .../test-harness/src/money_genesis_mint.rs | 3 +- .../test-harness/src/money_otc_swap.rs | 6 +- src/contract/test-harness/src/money_token.rs | 14 ++- .../test-harness/src/money_transfer.rs | 6 +- src/contract/test-harness/src/vks.rs | 70 +++++++++--- 17 files changed, 145 insertions(+), 130 deletions(-) diff --git a/src/contract/test-harness/.gitignore b/src/contract/test-harness/.gitignore index e9ea4e128..88054a5d8 100644 --- a/src/contract/test-harness/.gitignore +++ b/src/contract/test-harness/.gitignore @@ -1 +1,2 @@ vks.bin +pks.bin diff --git a/src/contract/test-harness/src/consensus_genesis_stake.rs b/src/contract/test-harness/src/consensus_genesis_stake.rs index 86c0db383..516f7918b 100644 --- a/src/contract/test-harness/src/consensus_genesis_stake.rs +++ b/src/contract/test-harness/src/consensus_genesis_stake.rs @@ -41,8 +41,10 @@ impl TestHarness { amount: u64, ) -> Result<(Transaction, ConsensusGenesisStakeParamsV1)> { let wallet = self.holders.get(holder).unwrap(); + let (mint_pk, mint_zkbin) = - self.proving_keys.get(&CONSENSUS_CONTRACT_ZKAS_MINT_NS_V1).unwrap(); + wallet.proving_keys.get(&CONSENSUS_CONTRACT_ZKAS_MINT_NS_V1.to_string()).unwrap(); + let tx_action_benchmark = self.tx_action_benchmarks.get_mut(&TxAction::ConsensusGenesisStake).unwrap(); let timer = Instant::now(); diff --git a/src/contract/test-harness/src/consensus_proposal.rs b/src/contract/test-harness/src/consensus_proposal.rs index e3b34faab..9fbefff06 100644 --- a/src/contract/test-harness/src/consensus_proposal.rs +++ b/src/contract/test-harness/src/consensus_proposal.rs @@ -44,8 +44,10 @@ impl TestHarness { staked_oc: &ConsensusOwnCoin, ) -> Result<(Transaction, ConsensusProposalParamsV1, SecretKey, SecretKey)> { let wallet = self.holders.get(holder).unwrap(); + let (proposal_pk, proposal_zkbin) = - self.proving_keys.get(&CONSENSUS_CONTRACT_ZKAS_PROPOSAL_NS_V1).unwrap(); + wallet.proving_keys.get(&CONSENSUS_CONTRACT_ZKAS_PROPOSAL_NS_V1.to_string()).unwrap(); + let tx_action_benchmark = self.tx_action_benchmarks.get_mut(&TxAction::ConsensusProposal).unwrap(); let timer = Instant::now(); diff --git a/src/contract/test-harness/src/consensus_stake.rs b/src/contract/test-harness/src/consensus_stake.rs index 658518669..82c882219 100644 --- a/src/contract/test-harness/src/consensus_stake.rs +++ b/src/contract/test-harness/src/consensus_stake.rs @@ -45,9 +45,12 @@ impl TestHarness { serial: pallas::Base, ) -> Result<(Transaction, ConsensusStakeParamsV1, SecretKey)> { let wallet = self.holders.get(holder).unwrap(); + let (mint_pk, mint_zkbin) = - self.proving_keys.get(&CONSENSUS_CONTRACT_ZKAS_MINT_NS_V1).unwrap(); - let (burn_pk, burn_zkbin) = self.proving_keys.get(&MONEY_CONTRACT_ZKAS_BURN_NS_V1).unwrap(); + wallet.proving_keys.get(&CONSENSUS_CONTRACT_ZKAS_MINT_NS_V1.to_string()).unwrap(); + let (burn_pk, burn_zkbin) = + wallet.proving_keys.get(&MONEY_CONTRACT_ZKAS_BURN_NS_V1.to_string()).unwrap(); + let tx_action_benchmark = self.tx_action_benchmarks.get_mut(&TxAction::ConsensusStake).unwrap(); let epoch = wallet.validator.read().await.consensus.time_keeper.slot_epoch(slot); diff --git a/src/contract/test-harness/src/consensus_unstake.rs b/src/contract/test-harness/src/consensus_unstake.rs index 071aae300..d8dd6ce6c 100644 --- a/src/contract/test-harness/src/consensus_unstake.rs +++ b/src/contract/test-harness/src/consensus_unstake.rs @@ -44,9 +44,12 @@ impl TestHarness { staked_oc: &ConsensusOwnCoin, ) -> Result<(Transaction, MoneyUnstakeParamsV1, SecretKey)> { let wallet = self.holders.get(holder).unwrap(); + let (burn_pk, burn_zkbin) = - self.proving_keys.get(&CONSENSUS_CONTRACT_ZKAS_BURN_NS_V1).unwrap(); - let (mint_pk, mint_zkbin) = self.proving_keys.get(&MONEY_CONTRACT_ZKAS_MINT_NS_V1).unwrap(); + wallet.proving_keys.get(&CONSENSUS_CONTRACT_ZKAS_BURN_NS_V1.to_string()).unwrap(); + let (mint_pk, mint_zkbin) = + wallet.proving_keys.get(&MONEY_CONTRACT_ZKAS_MINT_NS_V1.to_string()).unwrap(); + let tx_action_benchmark = self.tx_action_benchmarks.get_mut(&TxAction::ConsensusUnstake).unwrap(); let timer = Instant::now(); @@ -74,7 +77,7 @@ impl TestHarness { // Building Money::Unstake params let money_unstake_call_debris = MoneyUnstakeCallBuilder { owncoin: staked_oc.clone(), - recipient: self.holders.get_mut(holder).unwrap().keypair.public, + recipient: self.holders.get(holder).unwrap().keypair.public, value_blind: consensus_unstake_value_blind, nullifier: consensus_unstake_params.input.nullifier, merkle_root: consensus_unstake_params.input.merkle_root, diff --git a/src/contract/test-harness/src/consensus_unstake_request.rs b/src/contract/test-harness/src/consensus_unstake_request.rs index 4fe6775bf..6338238ba 100644 --- a/src/contract/test-harness/src/consensus_unstake_request.rs +++ b/src/contract/test-harness/src/consensus_unstake_request.rs @@ -44,10 +44,12 @@ impl TestHarness { staked_oc: &ConsensusOwnCoin, ) -> Result<(Transaction, ConsensusUnstakeReqParamsV1, SecretKey, SecretKey)> { let wallet = self.holders.get(holder).unwrap(); + let (burn_pk, burn_zkbin) = - self.proving_keys.get(&CONSENSUS_CONTRACT_ZKAS_BURN_NS_V1).unwrap(); + wallet.proving_keys.get(&CONSENSUS_CONTRACT_ZKAS_BURN_NS_V1.to_string()).unwrap(); let (mint_pk, mint_zkbin) = - self.proving_keys.get(&CONSENSUS_CONTRACT_ZKAS_MINT_NS_V1).unwrap(); + wallet.proving_keys.get(&CONSENSUS_CONTRACT_ZKAS_MINT_NS_V1.to_string()).unwrap(); + let tx_action_benchmark = self.tx_action_benchmarks.get_mut(&TxAction::ConsensusUnstakeRequest).unwrap(); let epoch = wallet.validator.read().await.consensus.time_keeper.slot_epoch(slot); diff --git a/src/contract/test-harness/src/dao_exec.rs b/src/contract/test-harness/src/dao_exec.rs index 031af2895..192b86983 100644 --- a/src/contract/test-harness/src/dao_exec.rs +++ b/src/contract/test-harness/src/dao_exec.rs @@ -51,10 +51,15 @@ impl TestHarness { yes_vote_blind: pallas::Scalar, all_vote_blind: pallas::Scalar, ) -> Result<(Transaction, MoneyTransferParamsV1, DaoExecParams)> { - let (mint_pk, mint_zkbin) = self.proving_keys.get(&MONEY_CONTRACT_ZKAS_MINT_NS_V1).unwrap(); - let (burn_pk, burn_zkbin) = self.proving_keys.get(&MONEY_CONTRACT_ZKAS_BURN_NS_V1).unwrap(); + let dao_wallet = self.holders.get(&Holder::Dao).unwrap(); + + let (mint_pk, mint_zkbin) = + dao_wallet.proving_keys.get(&MONEY_CONTRACT_ZKAS_MINT_NS_V1.to_string()).unwrap(); + let (burn_pk, burn_zkbin) = + dao_wallet.proving_keys.get(&MONEY_CONTRACT_ZKAS_BURN_NS_V1.to_string()).unwrap(); let (dao_exec_pk, dao_exec_zkbin) = - self.proving_keys.get(&DAO_CONTRACT_ZKAS_DAO_EXEC_NS).unwrap(); + dao_wallet.proving_keys.get(&DAO_CONTRACT_ZKAS_DAO_EXEC_NS.to_string()).unwrap(); + let tx_action_benchmark = self.tx_action_benchmarks.get_mut(&TxAction::DaoExec).unwrap(); let timer = Instant::now(); @@ -69,7 +74,6 @@ impl TestHarness { let change_user_data = dao_bulla.inner(); let change_user_data_blind = pallas::Base::random(&mut OsRng); - let dao_wallet = self.holders.get(&Holder::Dao).unwrap(); let coins: Vec = dao_wallet .unspent_money_coins .iter() diff --git a/src/contract/test-harness/src/dao_mint.rs b/src/contract/test-harness/src/dao_mint.rs index c40ec6e66..175021e3d 100644 --- a/src/contract/test-harness/src/dao_mint.rs +++ b/src/contract/test-harness/src/dao_mint.rs @@ -37,8 +37,12 @@ impl TestHarness { dao_info: &DaoInfo, dao_kp: &Keypair, ) -> Result<(Transaction, DaoMintParams)> { + // We assume DAO Holder exists at least + let wallet = self.holders.get(&Holder::Dao).unwrap(); + let (dao_mint_pk, dao_mint_zkbin) = - self.proving_keys.get(&DAO_CONTRACT_ZKAS_DAO_MINT_NS).unwrap(); + wallet.proving_keys.get(&DAO_CONTRACT_ZKAS_DAO_MINT_NS.to_string()).unwrap(); + let tx_action_benchmark = self.tx_action_benchmarks.get_mut(&TxAction::DaoMint).unwrap(); let timer = Instant::now(); diff --git a/src/contract/test-harness/src/dao_propose.rs b/src/contract/test-harness/src/dao_propose.rs index 083b0e359..2b45e4831 100644 --- a/src/contract/test-harness/src/dao_propose.rs +++ b/src/contract/test-harness/src/dao_propose.rs @@ -45,14 +45,16 @@ impl TestHarness { dao: &DaoInfo, dao_bulla: &DaoBulla, ) -> Result<(Transaction, DaoProposeParams, DaoProposalInfo)> { + let wallet = self.holders.get(proposer).unwrap(); + let (dao_propose_burn_pk, dao_propose_burn_zkbin) = - self.proving_keys.get(&DAO_CONTRACT_ZKAS_DAO_PROPOSE_BURN_NS).unwrap(); + wallet.proving_keys.get(&DAO_CONTRACT_ZKAS_DAO_PROPOSE_BURN_NS.to_string()).unwrap(); let (dao_propose_main_pk, dao_propose_main_zkbin) = - self.proving_keys.get(&DAO_CONTRACT_ZKAS_DAO_PROPOSE_MAIN_NS).unwrap(); + wallet.proving_keys.get(&DAO_CONTRACT_ZKAS_DAO_PROPOSE_MAIN_NS.to_string()).unwrap(); + let tx_action_benchmark = self.tx_action_benchmarks.get_mut(&TxAction::DaoPropose).unwrap(); let timer = Instant::now(); - let wallet = self.holders.get(proposer).unwrap(); let propose_owncoin: OwnCoin = wallet .unspent_money_coins .iter() diff --git a/src/contract/test-harness/src/dao_vote.rs b/src/contract/test-harness/src/dao_vote.rs index 71706f943..ef8ff878a 100644 --- a/src/contract/test-harness/src/dao_vote.rs +++ b/src/contract/test-harness/src/dao_vote.rs @@ -45,15 +45,15 @@ impl TestHarness { proposal: &DaoProposalInfo, proposal_bulla: &DaoProposalBulla, ) -> Result<(Transaction, DaoVoteParams)> { + let wallet = self.holders.get(voter).unwrap(); + let (dao_vote_burn_pk, dao_vote_burn_zkbin) = - self.proving_keys.get(&DAO_CONTRACT_ZKAS_DAO_VOTE_BURN_NS).unwrap(); + wallet.proving_keys.get(&DAO_CONTRACT_ZKAS_DAO_VOTE_BURN_NS.to_string()).unwrap(); let (dao_vote_main_pk, dao_vote_main_zkbin) = - self.proving_keys.get(&DAO_CONTRACT_ZKAS_DAO_VOTE_MAIN_NS).unwrap(); + wallet.proving_keys.get(&DAO_CONTRACT_ZKAS_DAO_VOTE_MAIN_NS.to_string()).unwrap(); let tx_action_benchmark = self.tx_action_benchmarks.get_mut(&TxAction::DaoVote).unwrap(); let timer = Instant::now(); - let wallet = self.holders.get(voter).unwrap(); - let (_proposal_leaf_pos, money_merkle_tree) = wallet.dao_prop_leafs.get(proposal_bulla).unwrap(); diff --git a/src/contract/test-harness/src/lib.rs b/src/contract/test-harness/src/lib.rs index 410817af5..d9ce694b5 100644 --- a/src/contract/test-harness/src/lib.rs +++ b/src/contract/test-harness/src/lib.rs @@ -16,11 +16,10 @@ * along with this program. If not, see . */ -use std::{collections::HashMap, time::Instant}; +use std::{collections::HashMap, io::Cursor, time::Instant}; use darkfi::{ blockchain::BlockInfo, - runtime::vm_runtime::SMART_CONTRACT_ZKAS_DB_NAME, tx::Transaction, util::{ pcg::Pcg32, @@ -32,30 +31,20 @@ use darkfi::{ zkas::ZkBinary, Result, }; -use darkfi_dao_contract::{ - model::{DaoBulla, DaoProposalBulla}, - DAO_CONTRACT_ZKAS_DAO_EXEC_NS, DAO_CONTRACT_ZKAS_DAO_MINT_NS, - DAO_CONTRACT_ZKAS_DAO_PROPOSE_BURN_NS, DAO_CONTRACT_ZKAS_DAO_PROPOSE_MAIN_NS, - DAO_CONTRACT_ZKAS_DAO_VOTE_BURN_NS, DAO_CONTRACT_ZKAS_DAO_VOTE_MAIN_NS, -}; +use darkfi_dao_contract::model::{DaoBulla, DaoProposalBulla}; use darkfi_money_contract::{ client::{ConsensusNote, ConsensusOwnCoin, MoneyNote, OwnCoin}, model::{ConsensusOutput, Output}, - CONSENSUS_CONTRACT_ZKAS_BURN_NS_V1, CONSENSUS_CONTRACT_ZKAS_MINT_NS_V1, - CONSENSUS_CONTRACT_ZKAS_PROPOSAL_NS_V1, MONEY_CONTRACT_ZKAS_BURN_NS_V1, - MONEY_CONTRACT_ZKAS_MINT_NS_V1, MONEY_CONTRACT_ZKAS_TOKEN_FRZ_NS_V1, - MONEY_CONTRACT_ZKAS_TOKEN_MINT_NS_V1, }; use darkfi_sdk::{ blockchain::Slot, bridgetree, crypto::{ pasta_prelude::Field, poseidon_hash, Keypair, MerkleNode, MerkleTree, Nullifier, PublicKey, - SecretKey, TokenId, CONSENSUS_CONTRACT_ID, DAO_CONTRACT_ID, MONEY_CONTRACT_ID, + SecretKey, TokenId, }, pasta::pallas, }; -use darkfi_serial::{deserialize, serialize}; use log::{info, warn}; use rand::rngs::OsRng; @@ -85,8 +74,8 @@ pub fn init_logger() { // We check this error so we can execute same file tests in parallel, // otherwise second one fails to init logger here. if simplelog::TermLogger::init( - simplelog::LevelFilter::Info, - //simplelog::LevelFilter::Debug, + //simplelog::LevelFilter::Info, + simplelog::LevelFilter::Debug, //simplelog::LevelFilter::Trace, cfg.build(), simplelog::TerminalMode::Mixed, @@ -133,6 +122,7 @@ pub struct Wallet { pub keypair: Keypair, pub token_mint_authority: Keypair, pub validator: ValidatorPtr, + pub proving_keys: HashMap, pub money_merkle_tree: MerkleTree, pub consensus_staked_merkle_tree: MerkleTree, pub consensus_unstaked_merkle_tree: MerkleTree, @@ -155,8 +145,17 @@ impl Wallet { let wallet = WalletDb::new(None, None)?; let sled_db = sled::Config::new().temporary(true).open()?; - // Use pregenerated vks - vks::inject(&sled_db)?; + // Use pregenerated vks and get pregenerated pks + let pks = vks::inject(&sled_db)?; + + let mut proving_keys = HashMap::new(); + for (bincode, namespace, pk) in pks { + let mut reader = Cursor::new(pk); + let zkbin = ZkBinary::decode(&bincode)?; + let circuit = ZkCircuit::new(empty_witnesses(&zkbin), &zkbin); + let _pk = ProvingKey::read(&mut reader, circuit)?; + proving_keys.insert(namespace, (_pk, zkbin)); + } // Generate validator // NOTE: we are not using consensus constants here so we @@ -187,6 +186,7 @@ impl Wallet { Ok(Self { keypair, + proving_keys, token_mint_authority, validator, money_merkle_tree, @@ -205,13 +205,12 @@ impl Wallet { pub struct TestHarness { pub holders: HashMap, - pub proving_keys: HashMap<&'static str, (ProvingKey, ZkBinary)>, pub tx_action_benchmarks: HashMap, pub genesis_block: blake3::Hash, } impl TestHarness { - pub async fn new(contracts: &[String]) -> Result { + pub async fn new(_contracts: &[String]) -> Result { let mut holders = HashMap::new(); let mut genesis_block = BlockInfo::default(); genesis_block.header.timestamp = Timestamp(1689772567); @@ -226,7 +225,7 @@ impl TestHarness { let alice_kp = Keypair::random(&mut rng); let alice = Wallet::new(alice_kp, &genesis_block, &faucet_pubkeys).await?; - // Alice is inserted at end of function + holders.insert(Holder::Alice, alice); let bob_kp = Keypair::random(&mut rng); let bob = Wallet::new(bob_kp, &genesis_block, &faucet_pubkeys).await?; @@ -244,60 +243,6 @@ impl TestHarness { let dao = Wallet::new(dao_kp, &genesis_block, &faucet_pubkeys).await?; holders.insert(Holder::Dao, dao); - // Get the zkas circuits and build proving keys - let mut proving_keys = HashMap::new(); - let alice_sled = alice.validator.read().await.blockchain.sled_db.clone(); - - macro_rules! mkpk { - ($db:expr, $ns:expr) => { - info!("Building ProvingKey for {}", $ns); - let zkas_bytes = $db.get(&serialize(&$ns))?.unwrap(); - let (zkbin, _): (Vec, Vec) = deserialize(&zkas_bytes)?; - let zkbin = ZkBinary::decode(&zkbin)?; - let witnesses = empty_witnesses(&zkbin); - let circuit = ZkCircuit::new(witnesses, &zkbin); - let pk = ProvingKey::build(13, &circuit); - proving_keys.insert($ns, (pk, zkbin)); - }; - } - - if contracts.contains(&"money".to_string()) { - let db_handle = alice.validator.read().await.blockchain.contracts.lookup( - &alice_sled, - &MONEY_CONTRACT_ID, - SMART_CONTRACT_ZKAS_DB_NAME, - )?; - mkpk!(db_handle, MONEY_CONTRACT_ZKAS_MINT_NS_V1); - mkpk!(db_handle, MONEY_CONTRACT_ZKAS_BURN_NS_V1); - mkpk!(db_handle, MONEY_CONTRACT_ZKAS_TOKEN_MINT_NS_V1); - mkpk!(db_handle, MONEY_CONTRACT_ZKAS_TOKEN_FRZ_NS_V1); - } - - if contracts.contains(&"consensus".to_string()) { - let db_handle = alice.validator.read().await.blockchain.contracts.lookup( - &alice_sled, - &CONSENSUS_CONTRACT_ID, - SMART_CONTRACT_ZKAS_DB_NAME, - )?; - mkpk!(db_handle, CONSENSUS_CONTRACT_ZKAS_MINT_NS_V1); - mkpk!(db_handle, CONSENSUS_CONTRACT_ZKAS_BURN_NS_V1); - mkpk!(db_handle, CONSENSUS_CONTRACT_ZKAS_PROPOSAL_NS_V1); - } - - if contracts.contains(&"dao".to_string()) { - let db_handle = alice.validator.read().await.blockchain.contracts.lookup( - &alice_sled, - &DAO_CONTRACT_ID, - SMART_CONTRACT_ZKAS_DB_NAME, - )?; - mkpk!(db_handle, DAO_CONTRACT_ZKAS_DAO_EXEC_NS); - mkpk!(db_handle, DAO_CONTRACT_ZKAS_DAO_MINT_NS); - mkpk!(db_handle, DAO_CONTRACT_ZKAS_DAO_VOTE_BURN_NS); - mkpk!(db_handle, DAO_CONTRACT_ZKAS_DAO_VOTE_MAIN_NS); - mkpk!(db_handle, DAO_CONTRACT_ZKAS_DAO_PROPOSE_BURN_NS); - mkpk!(db_handle, DAO_CONTRACT_ZKAS_DAO_PROPOSE_MAIN_NS); - } - // Build benchmarks map let mut tx_action_benchmarks = HashMap::new(); tx_action_benchmarks.insert(TxAction::MoneyAirdrop, TxActionBenchmarks::default()); @@ -317,15 +262,7 @@ impl TestHarness { tx_action_benchmarks.insert(TxAction::DaoVote, TxActionBenchmarks::default()); tx_action_benchmarks.insert(TxAction::DaoExec, TxActionBenchmarks::default()); - // Alice jumps down the rabbit hole - holders.insert(Holder::Alice, alice); - - Ok(Self { - holders, - proving_keys, - tx_action_benchmarks, - genesis_block: genesis_block.blockhash(), - }) + Ok(Self { holders, tx_action_benchmarks, genesis_block: genesis_block.blockhash() }) } pub async fn execute_erroneous_txs( diff --git a/src/contract/test-harness/src/money_airdrop.rs b/src/contract/test-harness/src/money_airdrop.rs index 579b07714..cb4530d30 100644 --- a/src/contract/test-harness/src/money_airdrop.rs +++ b/src/contract/test-harness/src/money_airdrop.rs @@ -47,8 +47,10 @@ impl TestHarness { ) -> Result<(Transaction, MoneyTransferParamsV1)> { let recipient = self.holders.get(holder).unwrap().keypair.public; let faucet = self.holders.get(&Holder::Faucet).unwrap(); - let (mint_pk, mint_zkbin) = self.proving_keys.get(&MONEY_CONTRACT_ZKAS_MINT_NS_V1).unwrap(); - let (burn_pk, burn_zkbin) = self.proving_keys.get(&MONEY_CONTRACT_ZKAS_BURN_NS_V1).unwrap(); + let (mint_pk, mint_zkbin) = + faucet.proving_keys.get(&MONEY_CONTRACT_ZKAS_MINT_NS_V1.to_string()).unwrap(); + let (burn_pk, burn_zkbin) = + faucet.proving_keys.get(&MONEY_CONTRACT_ZKAS_BURN_NS_V1.to_string()).unwrap(); let tx_action_benchmark = self.tx_action_benchmarks.get_mut(&TxAction::MoneyAirdrop).unwrap(); let timer = Instant::now(); diff --git a/src/contract/test-harness/src/money_genesis_mint.rs b/src/contract/test-harness/src/money_genesis_mint.rs index 78cd29e10..17b2f7855 100644 --- a/src/contract/test-harness/src/money_genesis_mint.rs +++ b/src/contract/test-harness/src/money_genesis_mint.rs @@ -40,7 +40,8 @@ impl TestHarness { amount: u64, ) -> Result<(Transaction, MoneyTokenMintParamsV1)> { let wallet = self.holders.get(holder).unwrap(); - let (mint_pk, mint_zkbin) = self.proving_keys.get(&MONEY_CONTRACT_ZKAS_MINT_NS_V1).unwrap(); + let (mint_pk, mint_zkbin) = + wallet.proving_keys.get(&MONEY_CONTRACT_ZKAS_MINT_NS_V1.to_string()).unwrap(); let tx_action_benchmark = self.tx_action_benchmarks.get_mut(&TxAction::MoneyGenesisMint).unwrap(); let timer = Instant::now(); diff --git a/src/contract/test-harness/src/money_otc_swap.rs b/src/contract/test-harness/src/money_otc_swap.rs index e441c3b2d..9bf343043 100644 --- a/src/contract/test-harness/src/money_otc_swap.rs +++ b/src/contract/test-harness/src/money_otc_swap.rs @@ -44,8 +44,10 @@ impl TestHarness { ) -> Result<(Transaction, MoneyTransferParamsV1)> { let wallet0 = self.holders.get(holder0).unwrap(); let wallet1 = self.holders.get(holder1).unwrap(); - let (mint_pk, mint_zkbin) = self.proving_keys.get(&MONEY_CONTRACT_ZKAS_MINT_NS_V1).unwrap(); - let (burn_pk, burn_zkbin) = self.proving_keys.get(&MONEY_CONTRACT_ZKAS_BURN_NS_V1).unwrap(); + let (mint_pk, mint_zkbin) = + wallet0.proving_keys.get(&MONEY_CONTRACT_ZKAS_MINT_NS_V1.to_string()).unwrap(); + let (burn_pk, burn_zkbin) = + wallet0.proving_keys.get(&MONEY_CONTRACT_ZKAS_BURN_NS_V1.to_string()).unwrap(); let tx_action_benchmark = self.tx_action_benchmarks.get_mut(&TxAction::MoneyOtcSwap).unwrap(); let timer = Instant::now(); diff --git a/src/contract/test-harness/src/money_token.rs b/src/contract/test-harness/src/money_token.rs index 47b6156c0..ef5c6723a 100644 --- a/src/contract/test-harness/src/money_token.rs +++ b/src/contract/test-harness/src/money_token.rs @@ -43,12 +43,17 @@ impl TestHarness { spend_hook: Option, user_data: Option, ) -> Result<(Transaction, MoneyTokenMintParamsV1)> { + let wallet = self.holders.get(holder).unwrap(); + let mint_authority = wallet.token_mint_authority; + let rcpt = self.holders.get(recipient).unwrap().keypair.public; - let mint_authority = self.holders.get(holder).unwrap().token_mint_authority; + let (mint_pk, mint_zkbin) = - self.proving_keys.get(&MONEY_CONTRACT_ZKAS_TOKEN_MINT_NS_V1).unwrap(); + wallet.proving_keys.get(&MONEY_CONTRACT_ZKAS_TOKEN_MINT_NS_V1.to_string()).unwrap(); + let tx_action_benchmark = self.tx_action_benchmarks.get_mut(&TxAction::MoneyTokenMint).unwrap(); + let timer = Instant::now(); let builder = TokenMintCallBuilder { @@ -106,9 +111,10 @@ impl TestHarness { &mut self, holder: &Holder, ) -> Result<(Transaction, MoneyTokenFreezeParamsV1)> { - let mint_authority = self.holders.get(holder).unwrap().token_mint_authority; + let wallet = self.holders.get(holder).unwrap(); + let mint_authority = wallet.token_mint_authority; let (frz_pk, frz_zkbin) = - self.proving_keys.get(&MONEY_CONTRACT_ZKAS_TOKEN_FRZ_NS_V1).unwrap(); + wallet.proving_keys.get(&MONEY_CONTRACT_ZKAS_TOKEN_FRZ_NS_V1.to_string()).unwrap(); let tx_action_benchmark = self.tx_action_benchmarks.get_mut(&TxAction::MoneyTokenFreeze).unwrap(); let timer = Instant::now(); diff --git a/src/contract/test-harness/src/money_transfer.rs b/src/contract/test-harness/src/money_transfer.rs index b49121902..3b0e778ec 100644 --- a/src/contract/test-harness/src/money_transfer.rs +++ b/src/contract/test-harness/src/money_transfer.rs @@ -45,8 +45,10 @@ impl TestHarness { ) -> Result<(Transaction, MoneyTransferParamsV1, Vec)> { let wallet = self.holders.get(holder).unwrap(); let rcpt = self.holders.get(recipient).unwrap().keypair.public; - let (mint_pk, mint_zkbin) = self.proving_keys.get(&MONEY_CONTRACT_ZKAS_MINT_NS_V1).unwrap(); - let (burn_pk, burn_zkbin) = self.proving_keys.get(&MONEY_CONTRACT_ZKAS_BURN_NS_V1).unwrap(); + let (mint_pk, mint_zkbin) = + wallet.proving_keys.get(&MONEY_CONTRACT_ZKAS_MINT_NS_V1.to_string()).unwrap(); + let (burn_pk, burn_zkbin) = + wallet.proving_keys.get(&MONEY_CONTRACT_ZKAS_BURN_NS_V1.to_string()).unwrap(); let tx_action_benchmark = self.tx_action_benchmarks.get_mut(&TxAction::MoneyTransfer).unwrap(); let timer = Instant::now(); diff --git a/src/contract/test-harness/src/vks.rs b/src/contract/test-harness/src/vks.rs index 4744883ee..03fa755a2 100644 --- a/src/contract/test-harness/src/vks.rs +++ b/src/contract/test-harness/src/vks.rs @@ -25,7 +25,7 @@ use std::{ use darkfi::{ runtime::vm_runtime::SMART_CONTRACT_ZKAS_DB_NAME, - zk::{empty_witnesses, VerifyingKey, ZkCircuit}, + zk::{empty_witnesses, ProvingKey, VerifyingKey, ZkCircuit}, zkas::ZkBinary, Result, }; @@ -48,23 +48,29 @@ use darkfi_serial::{deserialize, serialize}; use log::debug; /// Update this if any circuits are changed -const VKS_HASH: &str = "1a514858c589cf2b6f28930d7f6fbae9f7455661d68a7944b776a947811b3430"; +const VKS_HASH: &str = "afcbea36961a5b526dae2c448170953d9c16368211cc8c355f154caf1ac313d7"; +const PKS_HASH: &str = "6cf2bf9b2ffbc68c8f778971725de180862a040446db7d4f5bcc12e1e4552d7d"; -fn vks_path() -> Result { +fn pks_path(typ: &str) -> Result { let output = Command::new("git").arg("rev-parse").arg("--show-toplevel").output()?.stdout; let mut path = PathBuf::from(String::from_utf8(output[..output.len() - 1].to_vec())?); path.push("src"); path.push("contract"); path.push("test-harness"); - path.push("vks.bin"); + path.push(typ); Ok(path) } /// (Bincode, Namespace, VK) pub type Vks = Vec<(Vec, String, Vec)>; +pub type Pks = Vec<(Vec, String, Vec)>; -fn read_or_gen_vks() -> Result { - let vks_path = vks_path()?; +fn read_or_gen_vks_and_pks() -> Result<(Pks, Vks)> { + let vks_path = pks_path("vks.bin")?; + let pks_path = pks_path("pks.bin")?; + + let mut vks = None; + let mut pks = None; if vks_path.exists() { debug!("Found vks.bin"); @@ -75,16 +81,39 @@ fn read_or_gen_vks() -> Result { let known_hash = blake3::Hash::from_hex(VKS_HASH)?; let found_hash = blake3::hash(&data); - debug!("Known hash: {}", known_hash); - debug!("Found hash: {}", found_hash); + debug!("Known VKS hash: {}", known_hash); + debug!("Found VKS hash: {}", found_hash); if known_hash == found_hash { - return Ok(deserialize(&data)?) + vks = Some(deserialize(&data)?) } drop(f); } + if pks_path.exists() { + debug!("Found pks.bin"); + let mut f = File::open(pks_path.clone())?; + let mut data = vec![]; + f.read_to_end(&mut data)?; + + let known_hash = blake3::Hash::from_hex(PKS_HASH)?; + let found_hash = blake3::hash(&data); + + debug!("Known PKS hash: {}", known_hash); + debug!("Found PKS hash: {}", found_hash); + + if known_hash == found_hash { + pks = Some(deserialize(&data)?) + } + + drop(f); + } + + if pks.is_some() && vks.is_some() { + return Ok((pks.unwrap(), vks.unwrap())) + } + let bins = vec![ // Money &include_bytes!("../../money/proof/mint_v1.zk.bin")[..], @@ -107,6 +136,7 @@ fn read_or_gen_vks() -> Result { ]; let mut vks = vec![]; + let mut pks = vec![]; for bincode in bins.iter() { let zkbin = ZkBinary::decode(bincode)?; @@ -116,7 +146,12 @@ fn read_or_gen_vks() -> Result { let vk = VerifyingKey::build(13, &circuit); let mut vk_buf = vec![]; vk.write(&mut vk_buf)?; - vks.push((bincode.to_vec(), zkbin.namespace, vk_buf)) + vks.push((bincode.to_vec(), zkbin.namespace.clone(), vk_buf)); + + let pk = ProvingKey::build(13, &circuit); + let mut pk_buf = vec![]; + pk.write(&mut pk_buf)?; + pks.push((bincode.to_vec(), zkbin.namespace, pk_buf)); } debug!("Writing to {:?}", vks_path); @@ -126,12 +161,19 @@ fn read_or_gen_vks() -> Result { debug!("vks.bin {}", hash); f.write_all(&ser)?; - Ok(vks) + debug!("Writing to {:?}", pks_path); + let mut f = File::create(pks_path)?; + let ser = serialize(&pks); + let hash = blake3::hash(&ser); + debug!("pks.bin {}", hash); + f.write_all(&ser)?; + + Ok((pks, vks)) } -pub fn inject(sled_db: &sled::Db) -> Result<()> { +pub fn inject(sled_db: &sled::Db) -> Result { // Use pregenerated vks - let vks = read_or_gen_vks()?; + let (pks, vks) = read_or_gen_vks_and_pks()?; // Inject them into the db let money_zkas_tree_ptr = MONEY_CONTRACT_ID.hash_state_id(SMART_CONTRACT_ZKAS_DB_NAME); @@ -191,5 +233,5 @@ pub fn inject(sled_db: &sled::Db) -> Result<()> { } } - Ok(()) + Ok(pks) }