initial part of dao-exec zk proof

bin/daod/proof/dao-exec.zk

@@ -0,0 +1,54 @@
+constant "DaoExec" {
+	EcFixedPointShort VALUE_COMMIT_VALUE,
+	EcFixedPoint VALUE_COMMIT_RANDOM,
+}
+
+contract "DaoExec" {
+    # proposal params
+    Base proposal_dest_x,
+    Base proposal_dest_y,
+    Base proposal_amount,
+    Base proposal_serial,
+    Base proposal_token_id,
+    Base proposal_blind,
+
+    # DAO params
+    Base dao_proposer_limit,
+    Base dao_quorum,
+    Base dao_approval_ratio,
+    Base gov_token_id,
+    Base dao_public_x,
+    Base dao_public_y,
+    Base dao_bulla_blind,
+}
+
+circuit "DaoExec" {
+    dao_bulla = poseidon_hash(
+        dao_proposer_limit,
+        dao_quorum,
+        dao_approval_ratio,
+        gov_token_id,
+        dao_public_x,
+        dao_public_y,
+        dao_bulla_blind,
+        # @tmp-workaround
+        dao_bulla_blind,
+    );
+    # Proposal bulla is valid means DAO bulla is also valid
+    # because of dao-propose-main.zk, already checks that when
+    # we first create the proposal. So it is redundant here.
+
+    proposal_bulla = poseidon_hash(
+        proposal_dest_x,
+        proposal_dest_y,
+        proposal_amount,
+        proposal_serial,
+        proposal_token_id,
+        dao_bulla,
+        proposal_blind,
+        # @tmp-workaround
+        proposal_blind,
+    );
+    constrain_instance(proposal_bulla);
+}
+

bin/daod/src/demo.rs

@@ -288,6 +288,9 @@ pub async fn demo() -> Result<()> {
     let zk_dao_vote_burn_bincode = include_bytes!("../proof/dao-vote-burn.zk.bin");
     let zk_dao_vote_burn_bin = ZkBinary::decode(zk_dao_vote_burn_bincode)?;
     zk_bins.add_contract("dao-vote-burn".to_string(), zk_dao_vote_burn_bin, 13);
+    let zk_dao_exec_bincode = include_bytes!("../proof/dao-exec.zk.bin");
+    let zk_dao_exec_bin = ZkBinary::decode(zk_dao_exec_bincode)?;
+    zk_bins.add_contract("dao-exec".to_string(), zk_dao_exec_bin, 13);
 
     // State for money contracts
     let cashier_signature_secret = SecretKey::random(&mut OsRng);
@@ -652,15 +655,17 @@ pub async fn demo() -> Result<()> {
         bulla_blind: dao_bulla_blind,
     };
 
+    let proposal = dao_contract::propose::wallet::Proposal {
+        dest: user_keypair.public,
+        amount: 1000,
+        serial: pallas::Base::random(&mut OsRng),
+        token_id: xdrk_token_id,
+        blind: pallas::Base::random(&mut OsRng),
+    };
+
     let builder = dao_contract::propose::wallet::Builder {
         inputs: vec![input],
-        proposal: dao_contract::propose::wallet::Proposal {
-            dest: user_keypair.public,
-            amount: 1000,
-            serial: pallas::Base::random(&mut OsRng),
-            token_id: xdrk_token_id,
-            blind: pallas::Base::random(&mut OsRng),
-        },
+        proposal: proposal.clone(),
         dao: dao_params.clone(),
         dao_leaf_position,
         dao_merkle_path,
@@ -1036,6 +1041,8 @@ pub async fn demo() -> Result<()> {
     let user_coin_blind = pallas::Base::random(&mut OsRng);
     let dao_serial = pallas::Base::random(&mut OsRng);
     let dao_coin_blind = pallas::Base::random(&mut OsRng);
+    let input_value = treasury_note.value;
+    let input_value_blind = pallas::Scalar::random(&mut OsRng);
 
     let (treasury_leaf_position, treasury_merkle_path) = {
         let state = states.lookup::<money_contract::State>(&"Money".to_string()).unwrap();
@@ -1054,6 +1061,7 @@ pub async fn demo() -> Result<()> {
             secret: dao_keypair.secret,
             note: treasury_note,
             user_data_blind,
+            value_blind: input_value_blind,
         }],
         outputs: vec![
             // Sending money
@@ -1081,9 +1089,20 @@ pub async fn demo() -> Result<()> {
 
     let transfer_func_call = builder.build(&zk_bins)?;
 
-    let foo = dao_contract::exec::wallet::Foo { a: 5, b: 10 };
-
-    let builder = dao_contract::exec::wallet::Builder { foo };
+    let builder = dao_contract::exec::wallet::Builder {
+        proposal,
+        dao: dao_params,
+        win_votes,
+        total_votes,
+        win_votes_blind: total_vote_blinds,
+        total_votes_blind: total_value_blinds,
+        user_serial,
+        user_coin_blind,
+        dao_serial,
+        dao_coin_blind,
+        input_value,
+        input_value_blind,
+    };
     let exec_func_call = builder.build(&zk_bins);
 
     let tx = Transaction { func_calls: vec![transfer_func_call, exec_func_call] };

bin/daod/src/money_contract/transfer/wallet/builder.rs

@@ -53,6 +53,7 @@ pub struct BuilderInputInfo {
     pub secret: SecretKey,
     pub note: Note,
     pub user_data_blind: DrkUserDataBlind,
+    pub value_blind: DrkValueBlind,
 }
 
 pub struct BuilderOutputInfo {
@@ -113,7 +114,7 @@ impl Builder {
         let mut input_blinds = vec![];
         let mut signature_secrets = vec![];
         for input in self.inputs {
-            let value_blind = DrkValueBlind::random(&mut OsRng);
+            let value_blind = input.value_blind;
             input_blinds.push(value_blind);
 
             let signature_secret = SecretKey::random(&mut OsRng);