daod/exec: finish state_transition() and apply(). change coords.x/y() usage throughout dao to be less error prone

bin/daod/src/dao_contract/exec/validate.rs

@@ -1,10 +1,22 @@
-use pasta_curves::{arithmetic::CurveAffine, group::Curve, pallas};
+use pasta_curves::{
+    arithmetic::CurveAffine,
+    group::{Curve, Group},
+    pallas,
+};
 
-use darkfi::{crypto::types::DrkCircuitField, Error as DarkFiError};
+use darkfi::{
+    crypto::{coin::Coin, types::DrkCircuitField},
+    Error as DarkFiError,
+};
 
 use std::any::{Any, TypeId};
 
-use crate::demo::{CallDataBase, StateRegistry, Transaction, UpdateBase};
+use crate::{
+    dao_contract,
+    dao_contract::HashableBase,
+    demo::{CallDataBase, StateRegistry, Transaction, UpdateBase},
+    money_contract,
+};
 
 type Result<T> = std::result::Result<T, Error>;
 
@@ -15,6 +27,27 @@ pub enum Error {
 
     #[error("DarkFi error: {0}")]
     DarkFiError(String),
+
+    #[error("InvalidNumberOfFuncCalls")]
+    InvalidNumberOfFuncCalls,
+
+    #[error("InvalidIndex")]
+    InvalidIndex,
+
+    #[error("InvalidCallData")]
+    InvalidCallData,
+
+    #[error("InvalidNumberOfOutputs")]
+    InvalidNumberOfOutputs,
+
+    #[error("InvalidOutput")]
+    InvalidOutput,
+
+    #[error("InvalidValueCommit")]
+    InvalidValueCommit,
+
+    #[error("InvalidVoteCommit")]
+    InvalidVoteCommit,
 }
 
 impl From<DarkFiError> for Error {
@@ -35,16 +68,10 @@ pub struct CallData {
 impl CallDataBase for CallData {
     fn zk_public_values(&self) -> Vec<(String, Vec<DrkCircuitField>)> {
         let win_votes_coords = self.win_votes_commit.to_affine().coordinates().unwrap();
-        let win_votes_commit_x = *win_votes_coords.x();
-        let win_votes_commit_y = *win_votes_coords.y();
 
         let total_votes_coords = self.total_votes_commit.to_affine().coordinates().unwrap();
-        let total_votes_commit_x = *total_votes_coords.x();
-        let total_votes_commit_y = *total_votes_coords.y();
 
         let input_value_coords = self.input_value_commit.to_affine().coordinates().unwrap();
-        let input_value_commit_x = *input_value_coords.x();
-        let input_value_commit_y = *input_value_coords.y();
 
         vec![(
             "dao-exec".to_string(),
@@ -52,12 +79,12 @@ impl CallDataBase for CallData {
                 self.proposal,
                 self.coin_0,
                 self.coin_1,
-                win_votes_commit_x,
-                win_votes_commit_y,
-                total_votes_commit_x,
-                total_votes_commit_y,
-                input_value_commit_x,
-                input_value_commit_y,
+                *win_votes_coords.x(),
+                *win_votes_coords.y(),
+                *total_votes_coords.x(),
+                *total_votes_coords.y(),
+                *input_value_coords.x(),
+                *input_value_coords.y(),
                 *super::FUNC_ID,
                 pallas::Base::from(0),
                 pallas::Base::from(0),
@@ -85,27 +112,75 @@ pub fn state_transition(
     let call_data = call_data.unwrap();
 
     // Enforce tx has correct format:
-    // 1. There should only be 2 calldata's
+    // 1. There should only be 2 func_call's
+    if parent_tx.func_calls.len() != 2 {
+        return Err(Error::InvalidNumberOfFuncCalls)
+    }
+
     // 2. func_call_index == 1
+    if func_call_index != 1 {
+        return Err(Error::InvalidIndex)
+    }
+
     // 3. First item should be a Money::transfer() calldata
+    let money_transfer_call_data = parent_tx.func_calls[0].call_data.as_any();
+    let money_transfer_call_data =
+        money_transfer_call_data.downcast_ref::<money_contract::transfer::validate::CallData>();
+    let money_transfer_call_data = money_transfer_call_data.unwrap();
+    if money_transfer_call_data.type_id() !=
+        TypeId::of::<money_contract::transfer::validate::CallData>()
+    {
+        return Err(Error::InvalidCallData)
+    }
+
     // 4. Money::transfer() has exactly 2 outputs
+    if money_transfer_call_data.outputs.len() != 2 {
+        return Err(Error::InvalidNumberOfOutputs)
+    }
 
     // Checks:
-
     // 1. Check both coins in Money::transfer() are equal to our coin_0, coin_1
+    if money_transfer_call_data.outputs[0].revealed.coin != Coin(call_data.coin_0) {
+        return Err(Error::InvalidOutput)
+    }
+    if money_transfer_call_data.outputs[1].revealed.coin != Coin(call_data.coin_1) {
+        return Err(Error::InvalidOutput)
+    }
+
+    let mut input_value_commits = pallas::Point::identity();
+
     // 2. sum of Money::transfer() calldata input_value_commits == our input value commit
+    for input in &money_transfer_call_data.inputs {
+        input_value_commits += input.revealed.value_commit;
+    }
+    if input_value_commits != call_data.input_value_commit {
+        return Err(Error::InvalidValueCommit)
+    }
+
     // 3. get the ProposalVote from DAO::State
+    let state = states
+        .lookup::<dao_contract::State>(&"DAO".to_string())
+        .expect("Return type is not of type State");
+    let proposal_votes = state.proposal_votes.get(&HashableBase(call_data.proposal)).unwrap();
+
     // 4. check win/total_vote_commit is the same as in ProposalVote
+    if proposal_votes.vote_commits != call_data.win_votes_commit {
+        return Err(Error::InvalidVoteCommit)
+    }
 
-    // We need the proposal in here
-    Ok(Box::new(Update {}))
+    Ok(Box::new(Update { proposal: call_data.proposal }))
 }
 
 #[derive(Clone)]
-pub struct Update {}
+pub struct Update {
+    pub proposal: pallas::Base,
+}
 
 impl UpdateBase for Update {
     fn apply(mut self: Box<Self>, states: &mut StateRegistry) {
-        // Delete the ProposalVotes from DAO::State hashmap
+        let mut state = states
+            .lookup_mut::<dao_contract::State>(&"DAO".to_string())
+            .expect("Return type is not of type State");
+        state.proposal_votes.remove(&HashableBase(self.proposal)).unwrap();
     }
 }

bin/daod/src/dao_contract/exec/wallet.rs

@@ -37,11 +37,10 @@ pub struct Builder {
 impl Builder {
     pub fn build(self, zk_bins: &ZkContractTable) -> FuncCall {
         debug!(target: "dao_contract::exec::wallet::Builder", "build()");
+        debug!(target: "dao_contract::exec::wallet", "proposalserial{:?}", self.proposal.serial);
         let mut proofs = vec![];
 
         let proposal_dest_coords = self.proposal.dest.0.to_affine().coordinates().unwrap();
-        let proposal_dest_x = *proposal_dest_coords.x();
-        let proposal_dest_y = *proposal_dest_coords.y();
 
         let proposal_amount = pallas::Base::from(self.proposal.amount);
 
@@ -50,8 +49,6 @@ impl Builder {
         let dao_approval_ratio = pallas::Base::from(self.dao.approval_ratio);
 
         let dao_pubkey_coords = self.dao.public_key.0.to_affine().coordinates().unwrap();
-        let dao_public_x = *dao_pubkey_coords.x();
-        let dao_public_y = *dao_pubkey_coords.x();
 
         let user_spend_hook = pallas::Base::from(0);
         let user_data = pallas::Base::from(0);
@@ -63,16 +60,16 @@ impl Builder {
             dao_quorum,
             dao_approval_ratio,
             self.dao.gov_token_id,
-            dao_public_x,
-            dao_public_y,
+            *dao_pubkey_coords.x(),
+            *dao_pubkey_coords.y(),
             self.dao.bulla_blind,
             // @tmp-workaround
             self.dao.bulla_blind,
         ]);
 
         let proposal_bulla = poseidon_hash::<8>([
-            proposal_dest_x,
-            proposal_dest_y,
+            *proposal_dest_coords.x(),
+            *proposal_dest_coords.y(),
             proposal_amount,
             self.proposal.serial,
             self.proposal.token_id,
@@ -83,8 +80,8 @@ impl Builder {
         ]);
 
         let coin_0 = poseidon_hash::<8>([
-            proposal_dest_x,
-            proposal_dest_y,
+            *proposal_dest_coords.x(),
+            *proposal_dest_coords.y(),
             proposal_amount,
             self.proposal.token_id,
             self.proposal.serial,
@@ -94,8 +91,8 @@ impl Builder {
         ]);
 
         let coin_1 = poseidon_hash::<8>([
-            dao_public_x,
-            dao_public_y,
+            *dao_pubkey_coords.x(),
+            *dao_pubkey_coords.y(),
             change,
             self.proposal.token_id,
             self.dao_serial,
@@ -106,18 +103,12 @@ impl Builder {
 
         let win_votes_commit = pedersen_commitment_u64(self.win_votes, self.win_votes_blind);
         let win_votes_coords = win_votes_commit.to_affine().coordinates().unwrap();
-        let win_votes_commit_x = *win_votes_coords.x();
-        let win_votes_commit_y = *win_votes_coords.y();
 
         let total_votes_commit = pedersen_commitment_u64(self.total_votes, self.total_votes_blind);
         let total_votes_coords = total_votes_commit.to_affine().coordinates().unwrap();
-        let total_votes_commit_x = *total_votes_coords.x();
-        let total_votes_commit_y = *total_votes_coords.y();
 
         let input_value_commit = pedersen_commitment_u64(self.input_value, self.input_value_blind);
         let input_value_coords = input_value_commit.to_affine().coordinates().unwrap();
-        let input_value_commit_x = *input_value_coords.x();
-        let input_value_commit_y = *input_value_coords.y();
 
         let zk_info = zk_bins.lookup(&"dao-exec".to_string()).unwrap();
         let zk_info = if let ZkContractInfo::Binary(info) = zk_info {
@@ -130,8 +121,8 @@ impl Builder {
 
         let prover_witnesses = vec![
             // proposal params
-            Witness::Base(Value::known(proposal_dest_x)),
-            Witness::Base(Value::known(proposal_dest_y)),
+            Witness::Base(Value::known(*proposal_dest_coords.x())),
+            Witness::Base(Value::known(*proposal_dest_coords.y())),
             Witness::Base(Value::known(proposal_amount)),
             Witness::Base(Value::known(self.proposal.serial)),
             Witness::Base(Value::known(self.proposal.token_id)),
@@ -141,8 +132,8 @@ impl Builder {
             Witness::Base(Value::known(dao_quorum)),
             Witness::Base(Value::known(dao_approval_ratio)),
             Witness::Base(Value::known(self.dao.gov_token_id)),
-            Witness::Base(Value::known(dao_public_x)),
-            Witness::Base(Value::known(dao_public_y)),
+            Witness::Base(Value::known(*dao_pubkey_coords.x())),
+            Witness::Base(Value::known(*dao_pubkey_coords.y())),
             Witness::Base(Value::known(self.dao.bulla_blind)),
             // votes
             Witness::Base(Value::known(pallas::Base::from(self.win_votes))),
@@ -166,12 +157,12 @@ impl Builder {
             proposal_bulla,
             coin_0,
             coin_1,
-            win_votes_commit_x,
-            win_votes_commit_y,
-            total_votes_commit_x,
-            total_votes_commit_y,
-            input_value_commit_x,
-            input_value_commit_y,
+            *win_votes_coords.x(),
+            *win_votes_coords.y(),
+            *total_votes_coords.x(),
+            *total_votes_coords.y(),
+            *input_value_coords.x(),
+            *input_value_coords.y(),
             self.hook_dao_exec,
             user_spend_hook,
             user_data,

bin/daod/src/dao_contract/mint/wallet.rs

@@ -50,16 +50,14 @@ impl Builder {
         let dao_approval_ratio = pallas::Base::from(self.dao_approval_ratio);
 
         let dao_pubkey_coords = self.dao_pubkey.0.to_affine().coordinates().unwrap();
-        let dao_public_x = *dao_pubkey_coords.x();
-        let dao_public_y = *dao_pubkey_coords.x();
 
         let dao_bulla = poseidon_hash::<8>([
             dao_proposer_limit,
             dao_quorum,
             dao_approval_ratio,
             self.gov_token_id,
-            dao_public_x,
-            dao_public_y,
+            *dao_pubkey_coords.x(),
+            *dao_pubkey_coords.y(),
             self.dao_bulla_blind,
             // @tmp-workaround
             self.dao_bulla_blind,
@@ -79,8 +77,8 @@ impl Builder {
             Witness::Base(Value::known(dao_quorum)),
             Witness::Base(Value::known(dao_approval_ratio)),
             Witness::Base(Value::known(self.gov_token_id)),
-            Witness::Base(Value::known(dao_public_x)),
-            Witness::Base(Value::known(dao_public_y)),
+            Witness::Base(Value::known(*dao_pubkey_coords.x())),
+            Witness::Base(Value::known(*dao_pubkey_coords.y())),
             Witness::Base(Value::known(self.dao_bulla_blind)),
         ];
         let public_inputs = vec![dao_bulla.0];

bin/daod/src/dao_contract/mod.rs

@@ -9,4 +9,4 @@ pub mod exec;
 
 pub mod state;
 
-pub use state::{DaoBulla, State};
+pub use state::{DaoBulla, HashableBase, State};

bin/daod/src/dao_contract/propose/validate.rs

@@ -61,37 +61,31 @@ impl CallDataBase for CallData {
         for input in &self.inputs {
             total_funds_commit += input.value_commit;
             let value_coords = input.value_commit.to_affine().coordinates().unwrap();
-            let value_commit_x = *value_coords.x();
-            let value_commit_y = *value_coords.y();
 
             let sigpub_coords = input.signature_public.0.to_affine().coordinates().unwrap();
-            let sigpub_x = *sigpub_coords.x();
-            let sigpub_y = *sigpub_coords.y();
 
             zk_publics.push((
                 "dao-propose-burn".to_string(),
                 vec![
-                    value_commit_x,
-                    value_commit_y,
+                    *value_coords.x(),
+                    *value_coords.y(),
                     self.header.token_commit,
                     input.merkle_root.0,
-                    sigpub_x,
-                    sigpub_y,
+                    *sigpub_coords.x(),
+                    *sigpub_coords.y(),
                 ],
             ));
         }
 
         let total_funds_coords = total_funds_commit.to_affine().coordinates().unwrap();
-        let total_funds_x = *total_funds_coords.x();
-        let total_funds_y = *total_funds_coords.y();
         zk_publics.push((
             "dao-propose-main".to_string(),
             vec![
                 self.header.token_commit,
                 self.header.dao_merkle_root.0,
                 self.header.proposal_bulla,
-                total_funds_x,
-                total_funds_y,
+                *total_funds_coords.x(),
+                *total_funds_coords.y(),
             ],
         ));
 

bin/daod/src/dao_contract/propose/wallet.rs

@@ -26,6 +26,8 @@ use crate::{
     util::poseidon_hash,
 };
 
+use log::debug;
+
 #[derive(SerialEncodable, SerialDecodable)]
 pub struct Note {
     pub proposal: Proposal,
@@ -152,12 +154,12 @@ impl Builder {
             let sigpub_y = *sigpub_coords.y();
 
             let public_inputs = vec![
-                value_commit_x,
-                value_commit_y,
+                *value_coords.x(),
+                *value_coords.y(),
                 token_commit,
                 merkle_root.0,
-                sigpub_x,
-                sigpub_y,
+                *sigpub_coords.x(),
+                *sigpub_coords.y(),
             ];
             let circuit = ZkCircuit::new(prover_witnesses, zk_bin);
 
@@ -175,8 +177,6 @@ impl Builder {
 
         let total_funds_commit = pedersen_commitment_u64(total_funds, total_funds_blinds);
         let total_funds_coords = total_funds_commit.to_affine().coordinates().unwrap();
-        let total_funds_x = *total_funds_coords.x();
-        let total_funds_y = *total_funds_coords.y();
         let total_funds = pallas::Base::from(total_funds);
 
         let token_commit = poseidon_hash::<2>([self.dao.gov_token_id, gov_token_blind]);
@@ -192,16 +192,14 @@ impl Builder {
         let dao_approval_ratio = pallas::Base::from(self.dao.approval_ratio);
 
         let dao_pubkey_coords = self.dao.public_key.0.to_affine().coordinates().unwrap();
-        let dao_public_x = *dao_pubkey_coords.x();
-        let dao_public_y = *dao_pubkey_coords.x();
 
         let dao_bulla = poseidon_hash::<8>([
             dao_proposer_limit,
             dao_quorum,
             dao_approval_ratio,
             self.dao.gov_token_id,
-            dao_public_x,
-            dao_public_y,
+            *dao_pubkey_coords.x(),
+            *dao_pubkey_coords.y(),
             self.dao.bulla_blind,
             // @tmp-workaround
             self.dao.bulla_blind,
@@ -246,8 +244,8 @@ impl Builder {
             Witness::Base(Value::known(dao_quorum)),
             Witness::Base(Value::known(dao_approval_ratio)),
             Witness::Base(Value::known(self.dao.gov_token_id)),
-            Witness::Base(Value::known(dao_public_x)),
-            Witness::Base(Value::known(dao_public_y)),
+            Witness::Base(Value::known(*dao_pubkey_coords.x())),
+            Witness::Base(Value::known(*dao_pubkey_coords.y())),
             Witness::Base(Value::known(self.dao.bulla_blind)),
             Witness::Uint32(Value::known(dao_leaf_position.try_into().unwrap())),
             Witness::MerklePath(Value::known(self.dao_merkle_path.try_into().unwrap())),
@@ -256,8 +254,8 @@ impl Builder {
             token_commit,
             self.dao_merkle_root.0,
             proposal_bulla,
-            total_funds_x,
-            total_funds_y,
+            *total_funds_coords.x(),
+            *total_funds_coords.y(),
         ];
         let circuit = ZkCircuit::new(prover_witnesses, zk_bin);
 

bin/daod/src/dao_contract/state.rs

@@ -13,7 +13,7 @@ pub struct DaoBulla(pub pallas::Base);
 type MerkleTree = BridgeTree<MerkleNode, MERKLE_DEPTH>;
 
 #[derive(Eq, PartialEq)]
-pub struct HashableBase(pallas::Base);
+pub struct HashableBase(pub pallas::Base);
 
 impl std::hash::Hash for HashableBase {
     fn hash<H: Hasher>(&self, state: &mut H) {
@@ -47,7 +47,7 @@ pub struct State {
     //proposal_bullas: Vec<pallas::Base>,
     pub proposal_tree: MerkleTree,
     pub proposal_roots: Vec<MerkleNode>,
-    proposal_votes: HashMap<HashableBase, ProposalVotes>,
+    pub proposal_votes: HashMap<HashableBase, ProposalVotes>,
 }
 
 impl State {

bin/daod/src/dao_contract/vote/validate.rs

@@ -64,44 +64,36 @@ impl CallDataBase for CallData {
         for input in &self.inputs {
             total_value_commit += input.value_commit;
             let value_coords = input.value_commit.to_affine().coordinates().unwrap();
-            let value_commit_x = *value_coords.x();
-            let value_commit_y = *value_coords.y();
 
             let sigpub_coords = input.signature_public.0.to_affine().coordinates().unwrap();
-            let sigpub_x = *sigpub_coords.x();
-            let sigpub_y = *sigpub_coords.y();
 
             zk_publics.push((
                 "dao-vote-burn".to_string(),
                 vec![
                     input.nullifier.0,
-                    value_commit_x,
-                    value_commit_y,
+                    *value_coords.x(),
+                    *value_coords.y(),
                     self.header.token_commit,
                     input.merkle_root.0,
-                    sigpub_x,
-                    sigpub_y,
+                    *sigpub_coords.x(),
+                    *sigpub_coords.y(),
                 ],
             ));
         }
 
         let vote_commit_coords = self.header.vote_commit.to_affine().coordinates().unwrap();
-        let vote_commit_x = *vote_commit_coords.x();
-        let vote_commit_y = *vote_commit_coords.y();
 
         let value_commit_coords = total_value_commit.to_affine().coordinates().unwrap();
-        let value_commit_x = *value_commit_coords.x();
-        let value_commit_y = *value_commit_coords.y();
 
         zk_publics.push((
             "dao-vote-main".to_string(),
             vec![
                 self.header.token_commit,
                 self.header.proposal_bulla,
-                vote_commit_x,
-                vote_commit_y,
-                value_commit_x,
-                value_commit_y,
+                *vote_commit_coords.x(),
+                *vote_commit_coords.y(),
+                *value_commit_coords.x(),
+                *value_commit_coords.y(),
             ],
         ));
 

bin/daod/src/dao_contract/vote/wallet.rs

@@ -185,8 +185,6 @@ impl Builder {
         let token_commit = poseidon_hash::<2>([self.dao.gov_token_id, gov_token_blind]);
 
         let proposal_dest_coords = self.proposal.dest.0.to_affine().coordinates().unwrap();
-        let proposal_dest_x = *proposal_dest_coords.x();
-        let proposal_dest_y = *proposal_dest_coords.y();
 
         let proposal_amount = pallas::Base::from(self.proposal.amount);
 
@@ -195,24 +193,24 @@ impl Builder {
         let dao_approval_ratio = pallas::Base::from(self.dao.approval_ratio);
 
         let dao_pubkey_coords = self.dao.public_key.0.to_affine().coordinates().unwrap();
-        let dao_public_x = *dao_pubkey_coords.x();
-        let dao_public_y = *dao_pubkey_coords.x();
 
         let dao_bulla = poseidon_hash::<8>([
             dao_proposer_limit,
             dao_quorum,
             dao_approval_ratio,
             self.dao.gov_token_id,
-            dao_public_x,
-            dao_public_y,
+            *dao_pubkey_coords.x(),
+            *dao_pubkey_coords.y(),
             self.dao.bulla_blind,
             // @tmp-workaround
             self.dao.bulla_blind,
         ]);
 
         let proposal_bulla = poseidon_hash::<8>([
-            proposal_dest_x,
-            proposal_dest_y,
+            *proposal_dest_coords.x(),
+            *proposal_dest_coords.y(),
+            //proposal_dest_x,
+            //proposal_dest_y,
             proposal_amount,
             self.proposal.serial,
             self.proposal.token_id,
@@ -230,14 +228,10 @@ impl Builder {
         let vote_commit = pedersen_commitment_u64(weighted_vote, self.vote.vote_option_blind);
         debug!(target: "demo::dao_contract::vote::wallet::Builder", "vote commit: {:?}", vote_commit);
         let vote_coords = vote_commit.to_affine().coordinates().unwrap();
-        let vote_commit_x = *vote_coords.x();
-        let vote_commit_y = *vote_coords.y();
         let vote = pallas::Base::from(vote);
 
         let value_commit = pedersen_commitment_u64(value, value_blind);
         let value_coords = value_commit.to_affine().coordinates().unwrap();
-        let value_commit_x = *value_coords.x();
-        let value_commit_y = *value_coords.y();
         let value_base = pallas::Base::from(value);
 
         let zk_info = zk_bins.lookup(&"dao-vote-main".to_string()).unwrap();
@@ -250,8 +244,8 @@ impl Builder {
 
         let prover_witnesses = vec![
             // proposal params
-            Witness::Base(Value::known(proposal_dest_x)),
-            Witness::Base(Value::known(proposal_dest_y)),
+            Witness::Base(Value::known(*proposal_dest_coords.x())),
+            Witness::Base(Value::known(*proposal_dest_coords.y())),
             Witness::Base(Value::known(proposal_amount)),
             Witness::Base(Value::known(self.proposal.serial)),
             Witness::Base(Value::known(self.proposal.token_id)),
@@ -261,8 +255,8 @@ impl Builder {
             Witness::Base(Value::known(dao_quorum)),
             Witness::Base(Value::known(dao_approval_ratio)),
             Witness::Base(Value::known(self.dao.gov_token_id)),
-            Witness::Base(Value::known(dao_public_x)),
-            Witness::Base(Value::known(dao_public_y)),
+            Witness::Base(Value::known(*dao_pubkey_coords.x())),
+            Witness::Base(Value::known(*dao_pubkey_coords.y())),
             Witness::Base(Value::known(self.dao.bulla_blind)),
             // Vote
             Witness::Base(Value::known(vote)),
@@ -277,10 +271,10 @@ impl Builder {
         let public_inputs = vec![
             token_commit,
             proposal_bulla,
-            vote_commit_x,
-            vote_commit_y,
-            value_commit_x,
-            value_commit_y,
+            *vote_coords.x(),
+            *vote_coords.y(),
+            *value_coords.x(),
+            *value_coords.y(),
         ];
 
         let circuit = ZkCircuit::new(prover_witnesses, zk_bin);

bin/daod/src/demo.rs

@@ -1067,8 +1067,8 @@ pub async fn demo() -> Result<()> {
                 value: 1000,
                 token_id: xdrk_token_id,
                 public: user_keypair.public,
-                serial: user_serial,
-                coin_blind: user_coin_blind,
+                serial: proposal.serial,
+                coin_blind: proposal.blind,
                 spend_hook: pallas::Base::from(0),
                 user_data: pallas::Base::from(0),
             },
@@ -1080,7 +1080,7 @@ pub async fn demo() -> Result<()> {
                 serial: dao_serial,
                 coin_blind: dao_coin_blind,
                 spend_hook: *dao_contract::exec::FUNC_ID,
-                user_data: dao_bulla.0,
+                user_data: proposal_bulla,
             },
         ],
     };