auth_xfer: add zk proof (incomplete)

src/contract/dao/proof/dao-auth-money-transfer.zk

@@ -21,12 +21,6 @@ witness "DaoAuthMoneyTransfer" {
 	Base dao_public_x,
 	Base dao_public_y,
 	Base dao_bulla_blind,
-
-	# Votes
-	Base yes_vote_value,
-	Base all_vote_value,
-	Scalar yes_vote_blind,
-	Scalar all_vote_blind,
 }
 
 circuit "DaoAuthMoneyTransfer" {

src/contract/dao/src/client/auth_xfer.rs

@@ -30,18 +30,55 @@ use darkfi::{
     Result,
 };
 
-use crate::model::{Dao, DaoAuthMoneyTransferParams, DaoBlindAggregateVote, DaoProposal};
+use crate::model::{
+    Dao, DaoAuthMoneyTransferParams, DaoBlindAggregateVote, DaoProposal, VecAuthCallCommit,
+};
 
-pub struct DaoAuthMoneyTransferCall {}
+pub struct DaoAuthMoneyTransferCall {
+    pub proposal: DaoProposal,
+    pub dao: Dao,
+}
 
 impl DaoAuthMoneyTransferCall {
     pub fn make(
         self,
-        //_auth_xfer_zkbin: &ZkBinary,
-        //_auth_xfer_pk: &ProvingKey,
+        auth_xfer_zkbin: &ZkBinary,
+        auth_xfer_pk: &ProvingKey,
     ) -> Result<(DaoAuthMoneyTransferParams, Vec<Proof>)> {
-        let proofs = vec![];
-        let params = DaoAuthMoneyTransferParams {};
+        let mut proofs = vec![];
+        let params = DaoAuthMoneyTransferParams { proposal_bulla: self.proposal.to_bulla() };
+
+        let dao_proposer_limit = pallas::Base::from(self.dao.proposer_limit);
+        let dao_quorum = pallas::Base::from(self.dao.quorum);
+        let dao_approval_ratio_quot = pallas::Base::from(self.dao.approval_ratio_quot);
+        let dao_approval_ratio_base = pallas::Base::from(self.dao.approval_ratio_base);
+
+        let (dao_pub_x, dao_pub_y) = self.dao.public_key.xy();
+
+        let prover_witnesses = vec![
+            // proposal params
+            Witness::Base(Value::known(self.proposal.auth_calls.commit())),
+            Witness::Base(Value::known(self.proposal.user_data)),
+            Witness::Base(Value::known(self.proposal.blind)),
+            // DAO params
+            Witness::Base(Value::known(dao_proposer_limit)),
+            Witness::Base(Value::known(dao_quorum)),
+            Witness::Base(Value::known(dao_approval_ratio_quot)),
+            Witness::Base(Value::known(dao_approval_ratio_base)),
+            Witness::Base(Value::known(self.dao.gov_token_id.inner())),
+            Witness::Base(Value::known(dao_pub_x)),
+            Witness::Base(Value::known(dao_pub_y)),
+            Witness::Base(Value::known(self.dao.bulla_blind)),
+        ];
+
+        let public_inputs = vec![params.proposal_bulla.inner()];
+        //export_witness_json("witness.json", &prover_witnesses, &public_inputs);
+
+        let circuit = ZkCircuit::new(prover_witnesses, auth_xfer_zkbin);
+        let proof = Proof::create(auth_xfer_pk, &[circuit], &public_inputs, &mut OsRng)
+            .expect("DAO::exec() proving error!)");
+        proofs.push(proof);
+
         Ok((params, proofs))
     }
 }

src/contract/dao/src/entrypoint/auth_xfer.rs

@@ -34,7 +34,7 @@ use darkfi_serial::{deserialize, serialize, Encodable, WriteExt};
 use crate::{
     error::DaoError,
     model::{DaoAuthCall, DaoAuthMoneyTransferParams, DaoExecParams},
-    DaoFunction, DAO_CONTRACT_DB_PROPOSAL_BULLAS, DAO_CONTRACT_ZKAS_DAO_EXEC_NS,
+    DaoFunction, DAO_CONTRACT_DB_PROPOSAL_BULLAS, DAO_CONTRACT_ZKAS_DAO_AUTH_MONEY_TRANSFER_NS,
 };
 
 /// `get_metdata` function for `Dao::Exec`
@@ -43,9 +43,17 @@ pub(crate) fn dao_authxfer_get_metadata(
     call_idx: u32,
     calls: Vec<DarkLeaf<ContractCall>>,
 ) -> Result<Vec<u8>, ContractError> {
+    let self_ = &calls[call_idx as usize];
+    let params: DaoAuthMoneyTransferParams = deserialize(&self_.data.data[1..])?;
+
     let mut zk_public_inputs: Vec<(String, Vec<pallas::Base>)> = vec![];
     let signature_pubkeys: Vec<PublicKey> = vec![];
 
+    zk_public_inputs.push((
+        DAO_CONTRACT_ZKAS_DAO_AUTH_MONEY_TRANSFER_NS.to_string(),
+        vec![params.proposal_bulla.inner()],
+    ));
+
     let mut metadata = vec![];
     zk_public_inputs.encode(&mut metadata)?;
     signature_pubkeys.encode(&mut metadata)?;

src/contract/dao/src/entrypoint/mod.rs

@@ -72,13 +72,13 @@ darkfi_sdk::define_contract!(
 fn init_contract(cid: ContractId, _ix: &[u8]) -> ContractResult {
     // The zkas circuits can simply be embedded in the wasm and set up by
     // the initialization.
-    zkas_db_set(&include_bytes!("../proof/dao-mint.zk.bin")[..])?;
-    zkas_db_set(&include_bytes!("../proof/dao-propose-burn.zk.bin")[..])?;
-    zkas_db_set(&include_bytes!("../proof/dao-propose-main.zk.bin")[..])?;
-    zkas_db_set(&include_bytes!("../proof/dao-vote-burn.zk.bin")[..])?;
-    zkas_db_set(&include_bytes!("../proof/dao-vote-main.zk.bin")[..])?;
-    zkas_db_set(&include_bytes!("../proof/dao-exec.zk.bin")[..])?;
-    //zkas_db_set(&include_bytes!("../proof/dao-auth-money-transfer.zk.bin")[..])?;
+    zkas_db_set(&include_bytes!("../../proof/dao-mint.zk.bin")[..])?;
+    zkas_db_set(&include_bytes!("../../proof/dao-propose-burn.zk.bin")[..])?;
+    zkas_db_set(&include_bytes!("../../proof/dao-propose-main.zk.bin")[..])?;
+    zkas_db_set(&include_bytes!("../../proof/dao-vote-burn.zk.bin")[..])?;
+    zkas_db_set(&include_bytes!("../../proof/dao-vote-main.zk.bin")[..])?;
+    zkas_db_set(&include_bytes!("../../proof/dao-exec.zk.bin")[..])?;
+    zkas_db_set(&include_bytes!("../../proof/dao-auth-money-transfer.zk.bin")[..])?;
 
     // Set up db for general info
     let dao_info_db = match db_lookup(cid, DAO_CONTRACT_DB_INFO_TREE) {

src/contract/dao/src/lib.rs

@@ -74,8 +74,6 @@ pub const DAO_CONTRACT_KEY_LATEST_DAO_ROOT: &[u8] = b"dao_last_root";
 
 /// zkas dao mint circuit namespace
 pub const DAO_CONTRACT_ZKAS_DAO_MINT_NS: &str = "DaoMint";
-/// zkas dao exec circuit namespace
-pub const DAO_CONTRACT_ZKAS_DAO_EXEC_NS: &str = "DaoExec";
 /// zkas dao vote input circuit namespace
 pub const DAO_CONTRACT_ZKAS_DAO_VOTE_BURN_NS: &str = "DaoVoteInput";
 /// zkas dao vote main circuit namespace
@@ -84,3 +82,7 @@ pub const DAO_CONTRACT_ZKAS_DAO_VOTE_MAIN_NS: &str = "DaoVoteMain";
 pub const DAO_CONTRACT_ZKAS_DAO_PROPOSE_BURN_NS: &str = "DaoProposeInput";
 /// zkas dao propose main circuit namespace
 pub const DAO_CONTRACT_ZKAS_DAO_PROPOSE_MAIN_NS: &str = "DaoProposeMain";
+/// zkas dao exec circuit namespace
+pub const DAO_CONTRACT_ZKAS_DAO_EXEC_NS: &str = "DaoExec";
+/// zkas dao auth money_transfer circuit namespace
+pub const DAO_CONTRACT_ZKAS_DAO_AUTH_MONEY_TRANSFER_NS: &str = "DaoAuthMoneyTransfer";

src/contract/dao/src/model.rs

@@ -340,4 +340,7 @@ pub struct DaoExecUpdate {
 
 /// Parameters for `Dao::AuthMoneyTransfer`
 #[derive(Debug, Clone, SerialEncodable, SerialDecodable)]
-pub struct DaoAuthMoneyTransferParams {}
+pub struct DaoAuthMoneyTransferParams {
+    /// The proposal bulla
+    pub proposal_bulla: DaoProposalBulla,
+}

src/contract/test-harness/src/dao_exec.rs

@@ -25,7 +25,7 @@ use darkfi::{
 use darkfi_dao_contract::{
     client::{DaoAuthMoneyTransferCall, DaoExecCall},
     model::{Dao, DaoBulla, DaoExecParams, DaoProposal},
-    DaoFunction, DAO_CONTRACT_ZKAS_DAO_EXEC_NS,
+    DaoFunction, DAO_CONTRACT_ZKAS_DAO_AUTH_MONEY_TRANSFER_NS, DAO_CONTRACT_ZKAS_DAO_EXEC_NS,
 };
 use darkfi_money_contract::{
     client::transfer_v1 as xfer,
@@ -67,6 +67,10 @@ impl TestHarness {
             self.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.to_string()).unwrap();
+        let (dao_auth_xfer_pk, dao_auth_xfer_zkbin) = self
+            .proving_keys
+            .get(&DAO_CONTRACT_ZKAS_DAO_AUTH_MONEY_TRANSFER_NS.to_string())
+            .unwrap();
 
         let tx_action_benchmark = self.tx_action_benchmarks.get_mut(&TxAction::DaoExec).unwrap();
         let timer = Instant::now();
@@ -179,16 +183,18 @@ impl TestHarness {
         let exec_call = ContractCall { contract_id: *DAO_CONTRACT_ID, data };
 
         // Auth module
-        let authxfer_builder = DaoAuthMoneyTransferCall {};
-        let (authxfer_params, authxfer_proofs) = authxfer_builder.make()?;
+        let auth_xfer_builder =
+            DaoAuthMoneyTransferCall { proposal: proposal.clone(), dao: dao.clone() };
+        let (auth_xfer_params, auth_xfer_proofs) =
+            auth_xfer_builder.make(dao_auth_xfer_zkbin, dao_auth_xfer_pk)?;
         let mut data = vec![DaoFunction::AuthMoneyTransfer as u8];
-        authxfer_params.encode(&mut data)?;
-        let authxfer_call = ContractCall { contract_id: *DAO_CONTRACT_ID, data };
+        auth_xfer_params.encode(&mut data)?;
+        let auth_xfer_call = ContractCall { contract_id: *DAO_CONTRACT_ID, data };
 
         // We need to construct this tree, where exec is the parent:
         //
         //   exec ->
-        //       authxfer
+        //       auth_xfer
         //       xfer
         //
 
@@ -197,23 +203,23 @@ impl TestHarness {
         //    vec![],
         //)?;
         //tx_builder
-        //    .append(ContractCallLeaf { call: authxfer_call, proofs: authxfer_proofs }, vec![])?;
+        //    .append(ContractCallLeaf { call: auth_xfer_call, proofs: auth_xfer_proofs }, vec![])?;
         //tx_builder
         //let mut tx = tx_builder.build()?;
 
         let mut tx = Transaction {
             calls: vec![
-                DarkLeaf { data: authxfer_call, parent_index: Some(2), children_indexes: vec![] },
+                DarkLeaf { data: auth_xfer_call, parent_index: Some(2), children_indexes: vec![] },
                 DarkLeaf { data: xfer_call, parent_index: Some(2), children_indexes: vec![] },
                 DarkLeaf { data: exec_call, parent_index: None, children_indexes: vec![0, 1] },
             ],
-            proofs: vec![authxfer_proofs, xfer_secrets.proofs, exec_proofs],
+            proofs: vec![auth_xfer_proofs, xfer_secrets.proofs, exec_proofs],
             signatures: vec![],
         };
-        let authxfer_sigs = vec![];
+        let auth_xfer_sigs = vec![];
         let xfer_sigs = tx.create_sigs(&mut OsRng, &xfer_secrets.signature_secrets)?;
         let exec_sigs = tx.create_sigs(&mut OsRng, &[exec_signature_secret])?;
-        tx.signatures = vec![authxfer_sigs, xfer_sigs, exec_sigs];
+        tx.signatures = vec![auth_xfer_sigs, xfer_sigs, exec_sigs];
         tx_action_benchmark.creation_times.push(timer.elapsed());
 
         // Calculate transaction sizes

src/contract/test-harness/src/vks.rs

@@ -30,9 +30,10 @@ use darkfi::{
     Result,
 };
 use darkfi_dao_contract::{
-    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,
+    DAO_CONTRACT_ZKAS_DAO_AUTH_MONEY_TRANSFER_NS, 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_deployooor_contract::DEPLOY_CONTRACT_ZKAS_DERIVE_NS_V1;
 use darkfi_money_contract::{
@@ -122,11 +123,12 @@ pub fn read_or_gen_vks_and_pks() -> Result<(Pks, Vks)> {
         &include_bytes!("../../money/proof/token_freeze_v1.zk.bin")[..],
         // DAO
         &include_bytes!("../../dao/proof/dao-mint.zk.bin")[..],
-        &include_bytes!("../../dao/proof/dao-exec.zk.bin")[..],
         &include_bytes!("../../dao/proof/dao-propose-burn.zk.bin")[..],
         &include_bytes!("../../dao/proof/dao-propose-main.zk.bin")[..],
         &include_bytes!("../../dao/proof/dao-vote-burn.zk.bin")[..],
         &include_bytes!("../../dao/proof/dao-vote-main.zk.bin")[..],
+        &include_bytes!("../../dao/proof/dao-exec.zk.bin")[..],
+        &include_bytes!("../../dao/proof/dao-auth-money-transfer.zk.bin")[..],
         // Consensus
         &include_bytes!("../../consensus/proof/consensus_burn_v1.zk.bin")[..],
         &include_bytes!("../../consensus/proof/consensus_mint_v1.zk.bin")[..],
@@ -207,11 +209,12 @@ pub fn inject(sled_db: &sled::Db, vks: &Vks) -> Result<()> {
 
             // DAO circuits
             DAO_CONTRACT_ZKAS_DAO_MINT_NS |
-            DAO_CONTRACT_ZKAS_DAO_EXEC_NS |
             DAO_CONTRACT_ZKAS_DAO_VOTE_BURN_NS |
             DAO_CONTRACT_ZKAS_DAO_VOTE_MAIN_NS |
             DAO_CONTRACT_ZKAS_DAO_PROPOSE_BURN_NS |
-            DAO_CONTRACT_ZKAS_DAO_PROPOSE_MAIN_NS => {
+            DAO_CONTRACT_ZKAS_DAO_PROPOSE_MAIN_NS |
+            DAO_CONTRACT_ZKAS_DAO_EXEC_NS |
+            DAO_CONTRACT_ZKAS_DAO_AUTH_MONEY_TRANSFER_NS => {
                 let key = serialize(&namespace.as_str());
                 let value = serialize(&(bincode.clone(), vk.clone()));
                 dao_zkas_tree.insert(key, value)?;