daod/ exec: atomically apply all updates

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

@@ -183,10 +183,13 @@ pub struct Update {
 }
 
 impl UpdateBase for Update {
-    fn apply(mut self: Box<Self>, states: &mut StateRegistry) {
+    fn apply(self: Box<Self>, states: &mut StateRegistry) {
         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();
     }
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
 }

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

@@ -4,14 +4,14 @@ use darkfi::crypto::types::DrkCircuitField;
 
 use crate::{
     dao_contract::{DaoBulla, State},
-    demo::{CallDataBase, StateRegistry, Transaction},
+    demo::{CallDataBase, StateRegistry, Transaction, UpdateBase},
 };
 
 pub fn state_transition(
     _states: &StateRegistry,
     func_call_index: usize,
     parent_tx: &Transaction,
-) -> Result<Update> {
+) -> Result<Box<dyn UpdateBase>> {
     let func_call = &parent_tx.func_calls[func_call_index];
     let call_data = func_call.call_data.as_any();
 
@@ -21,18 +21,24 @@ pub fn state_transition(
     // This will be inside wasm so unwrap is fine.
     let call_data = call_data.unwrap();
 
-    Ok(Update { dao_bulla: call_data.dao_bulla.clone() })
+    Ok(Box::new(Update { dao_bulla: call_data.dao_bulla.clone() }))
 }
 
+#[derive(Clone)]
 pub struct Update {
     pub dao_bulla: DaoBulla,
 }
 
-pub fn apply(states: &mut StateRegistry, update: Update) {
-    // Lookup dao_contract state from registry
-    let state = states.lookup_mut::<State>(&"DAO".to_string()).unwrap();
-    // Add dao_bulla to state.dao_bullas
-    state.add_dao_bulla(update.dao_bulla);
+impl UpdateBase for Update {
+    fn apply(self: Box<Self>, states: &mut StateRegistry) {
+        // Lookup dao_contract state from registry
+        let state = states.lookup_mut::<State>(&"DAO".to_string()).unwrap();
+        // Add dao_bulla to state.dao_bullas
+        state.add_dao_bulla(self.dao_bulla);
+    }
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
 }
 
 #[derive(Debug, Clone, thiserror::Error)]

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

@@ -16,7 +16,7 @@ use std::any::{Any, TypeId};
 
 use crate::{
     dao_contract::State as DaoState,
-    demo::{CallDataBase, StateRegistry, Transaction},
+    demo::{CallDataBase, StateRegistry, Transaction, UpdateBase},
     money_contract::state::State as MoneyState,
     note::EncryptedNote2,
 };
@@ -116,7 +116,7 @@ pub fn state_transition(
     states: &StateRegistry,
     func_call_index: usize,
     parent_tx: &Transaction,
-) -> Result<Update> {
+) -> Result<Box<dyn UpdateBase>> {
     let func_call = &parent_tx.func_calls[func_call_index];
     let call_data = func_call.call_data.as_any();
 
@@ -159,14 +159,20 @@ pub fn state_transition(
     // TODO: look at gov tokens avoid using already spent ones
     // Need to spend original coin and generate 2 nullifiers?
 
-    Ok(Update { proposal_bulla: call_data.header.proposal_bulla })
+    Ok(Box::new(Update { proposal_bulla: call_data.header.proposal_bulla }))
 }
 
+#[derive(Clone)]
 pub struct Update {
     pub proposal_bulla: pallas::Base,
 }
 
-pub fn apply(states: &mut StateRegistry, update: Update) {
-    let state = states.lookup_mut::<DaoState>(&"DAO".to_string()).unwrap();
-    state.add_proposal_bulla(update.proposal_bulla);
+impl UpdateBase for Update {
+    fn apply(self: Box<Self>, states: &mut StateRegistry) {
+        let state = states.lookup_mut::<DaoState>(&"DAO".to_string()).unwrap();
+        state.add_proposal_bulla(self.proposal_bulla);
+    }
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
 }

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

@@ -16,7 +16,7 @@ use std::any::{Any, TypeId};
 
 use crate::{
     dao_contract::State as DaoState,
-    demo::{CallDataBase, StateRegistry, Transaction},
+    demo::{CallDataBase, StateRegistry, Transaction, UpdateBase},
     money_contract::state::State as MoneyState,
     note::EncryptedNote2,
 };
@@ -125,7 +125,7 @@ pub fn state_transition(
     states: &StateRegistry,
     func_call_index: usize,
     parent_tx: &Transaction,
-) -> Result<Update> {
+) -> Result<Box<dyn UpdateBase>> {
     let func_call = &parent_tx.func_calls[func_call_index];
     let call_data = func_call.call_data.as_any();
 
@@ -183,12 +183,12 @@ pub fn state_transition(
         }
     }
 
-    Ok(Update {
+    Ok(Box::new(Update {
         proposal_bulla: call_data.header.proposal_bulla,
         vote_nulls,
         vote_commit: call_data.header.vote_commit,
         value_commit: total_value_commit,
-    })
+    }))
 }
 
 #[derive(Clone)]
@@ -199,10 +199,15 @@ pub struct Update {
     pub value_commit: pallas::Point,
 }
 
-pub fn apply(states: &mut StateRegistry, mut update: Update) {
-    let state = states.lookup_mut::<DaoState>(&"DAO".to_string()).unwrap();
-    let votes_info = state.lookup_proposal_votes_mut(update.proposal_bulla).unwrap();
-    votes_info.vote_commits += update.vote_commit;
-    votes_info.value_commits += update.value_commit;
-    votes_info.vote_nulls.append(&mut update.vote_nulls);
+impl UpdateBase for Update {
+    fn apply(mut self: Box<Self>, states: &mut StateRegistry) {
+        let state = states.lookup_mut::<DaoState>(&"DAO".to_string()).unwrap();
+        let votes_info = state.lookup_proposal_votes_mut(self.proposal_bulla).unwrap();
+        votes_info.vote_commits += self.vote_commit;
+        votes_info.value_commits += self.value_commit;
+        votes_info.vote_nulls.append(&mut self.vote_nulls);
+    }
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
 }

bin/daod/src/demo.rs

@@ -179,6 +179,9 @@ impl StateRegistry {
 
 pub trait UpdateBase {
     fn apply(self: Box<Self>, states: &mut StateRegistry);
+
+    // For upcasting to Update
+    fn as_any(&self) -> &dyn Any;
 }
 
 ///////////////////////////////////////////////////
@@ -209,17 +212,23 @@ pub async fn example() -> Result<()> {
 
     //// Validator
 
+    let mut updates = vec![];
+    // Validate all function calls in the tx
     for (idx, func_call) in tx.func_calls.iter().enumerate() {
         if func_call.func_id == "Example::foo()" {
             debug!("example_contract::foo::state_transition()");
 
-            // TODO: separate this 2 things
             let update = example_contract::foo::validate::state_transition(&states, idx, &tx)
                 .expect("example_contract::foo::validate::state_transition() failed!");
-            example_contract::foo::validate::apply(&mut states, update);
+            updates.push(update);
         }
     }
 
+    // Atomically apply all changes
+    for update in updates {
+        update.apply(&mut states);
+    }
+
     tx.zk_verify(&zk_bins);
 
     Ok(())
@@ -335,6 +344,8 @@ pub async fn demo() -> Result<()> {
 
     //// Validator
 
+    let mut updates = vec![];
+    // Validate all function calls in the tx
     for (idx, func_call) in tx.func_calls.iter().enumerate() {
         // So then the verifier will lookup the corresponding state_transition and apply
         // functions based off the func_id
@@ -343,10 +354,15 @@ pub async fn demo() -> Result<()> {
 
             let update = dao_contract::mint::validate::state_transition(&states, idx, &tx)
                 .expect("dao_contract::mint::validate::state_transition() failed!");
-            dao_contract::mint::validate::apply(&mut states, update);
+            updates.push(update);
         }
     }
 
+    // Atomically apply all changes
+    for update in updates {
+        update.apply(&mut states);
+    }
+
     tx.zk_verify(&zk_bins);
 
     // Wallet stuff
@@ -422,6 +438,8 @@ pub async fn demo() -> Result<()> {
 
     //// Validator
 
+    let mut updates = vec![];
+    // Validate all function calls in the tx
     for (idx, func_call) in tx.func_calls.iter().enumerate() {
         // So then the verifier will lookup the corresponding state_transition and apply
         // functions based off the func_id
@@ -430,10 +448,15 @@ pub async fn demo() -> Result<()> {
 
             let update = money_contract::transfer::validate::state_transition(&states, idx, &tx)
                 .expect("money_contract::transfer::validate::state_transition() failed!");
-            update.apply(&mut states);
+            updates.push(update);
         }
     }
 
+    // Atomically apply all changes
+    for update in updates {
+        update.apply(&mut states);
+    }
+
     tx.zk_verify(&zk_bins);
 
     //// Wallet
@@ -542,6 +565,8 @@ pub async fn demo() -> Result<()> {
 
     //// Validator
 
+    let mut updates = vec![];
+    // Validate all function calls in the tx
     for (idx, func_call) in tx.func_calls.iter().enumerate() {
         // So then the verifier will lookup the corresponding state_transition and apply
         // functions based off the func_id
@@ -550,10 +575,15 @@ pub async fn demo() -> Result<()> {
 
             let update = money_contract::transfer::validate::state_transition(&states, idx, &tx)
                 .expect("money_contract::transfer::validate::state_transition() failed!");
-            update.apply(&mut states);
+            updates.push(update);
         }
     }
 
+    // Atomically apply all changes
+    for update in updates {
+        update.apply(&mut states);
+    }
+
     tx.zk_verify(&zk_bins);
 
     //// Wallet
@@ -677,16 +707,23 @@ pub async fn demo() -> Result<()> {
 
     //// Validator
 
+    let mut updates = vec![];
+    // Validate all function calls in the tx
     for (idx, func_call) in tx.func_calls.iter().enumerate() {
         if func_call.func_id == "DAO::propose()" {
             debug!(target: "demo", "dao_contract::propose::state_transition()");
 
             let update = dao_contract::propose::validate::state_transition(&states, idx, &tx)
                 .expect("dao_contract::propose::validate::state_transition() failed!");
-            dao_contract::propose::validate::apply(&mut states, update);
+            updates.push(update);
         }
     }
 
+    // Atomically apply all changes
+    for update in updates {
+        update.apply(&mut states);
+    }
+
     tx.zk_verify(&zk_bins);
 
     //// Wallet
@@ -742,8 +779,8 @@ pub async fn demo() -> Result<()> {
 
     debug!(target: "demo", "Stage 5. Start voting");
 
-    // We save updates here for testing.
-    let mut updates = Vec::new();
+    // We were previously saving updates here for testing
+    // let mut updates = vec![];
 
     // User 1: YES
 
@@ -787,17 +824,23 @@ pub async fn demo() -> Result<()> {
 
     //// Validator
 
+    let mut updates = vec![];
+    // Validate all function calls in the tx
     for (idx, func_call) in tx.func_calls.iter().enumerate() {
         if func_call.func_id == "DAO::vote()" {
             debug!(target: "demo", "dao_contract::vote::state_transition()");
 
             let update = dao_contract::vote::validate::state_transition(&states, idx, &tx)
                 .expect("dao_contract::vote::validate::state_transition() failed!");
-            dao_contract::vote::validate::apply(&mut states, update.clone());
             updates.push(update);
         }
     }
 
+    // Atomically apply all changes
+    for update in updates {
+        update.apply(&mut states);
+    }
+
     tx.zk_verify(&zk_bins);
 
     //// Wallet
@@ -863,17 +906,23 @@ pub async fn demo() -> Result<()> {
 
     //// Validator
 
+    let mut updates = vec![];
+    // Validate all function calls in the tx
     for (idx, func_call) in tx.func_calls.iter().enumerate() {
         if func_call.func_id == "DAO::vote()" {
             debug!(target: "demo", "dao_contract::vote::state_transition()");
 
             let update = dao_contract::vote::validate::state_transition(&states, idx, &tx)
                 .expect("dao_contract::vote::validate::state_transition() failed!");
-            dao_contract::vote::validate::apply(&mut states, update.clone());
             updates.push(update);
         }
     }
 
+    // Atomically apply all changes
+    for update in updates {
+        update.apply(&mut states);
+    }
+
     tx.zk_verify(&zk_bins);
 
     //// Wallet
@@ -939,17 +988,23 @@ pub async fn demo() -> Result<()> {
 
     //// Validator
 
+    let mut updates = vec![];
+    // Validate all function calls in the tx
     for (idx, func_call) in tx.func_calls.iter().enumerate() {
         if func_call.func_id == "DAO::vote()" {
             debug!(target: "demo", "dao_contract::vote::state_transition()");
 
             let update = dao_contract::vote::validate::state_transition(&states, idx, &tx)
                 .expect("dao_contract::vote::validate::state_transition() failed!");
-            dao_contract::vote::validate::apply(&mut states, update.clone());
             updates.push(update);
         }
     }
 
+    // Atomically apply all changes
+    for update in updates {
+        update.apply(&mut states);
+    }
+
     tx.zk_verify(&zk_bins);
 
     //// Wallet
@@ -989,13 +1044,16 @@ pub async fn demo() -> Result<()> {
     let mut total_value_commit = pallas::Point::identity();
     let mut total_vote_commit = pallas::Point::identity();
 
-    assert!(updates.len() == 3);
+    //assert!(updates.len() == 3);
 
-    for (i, (note, update)) in
-        [vote_note_1, vote_note_2, vote_note_3].iter().zip(updates).enumerate()
+    for (i, note /* update*/) in [vote_note_1, vote_note_2, vote_note_3]
+        .iter() /*.zip(updates)*/
+        .enumerate()
     {
         let value_commit = pedersen_commitment_u64(note.value, note.value_blind);
-        assert!(update.value_commit == value_commit);
+        //let update = update.as_any().downcast_ref::<dao_contract::vote::validate::Update>();
+        //let update = update.unwrap();
+        //assert!(update.value_commit == value_commit);
 
         total_value_commit += value_commit;
         total_value_blinds += note.value_blind;
@@ -1005,7 +1063,7 @@ pub async fn demo() -> Result<()> {
             note.vote.vote_option_blind,
         );
 
-        assert!(update.vote_commit == vote_commit);
+        //assert!(update.vote_commit == vote_commit);
 
         total_vote_commit += vote_commit;
         total_vote_blinds += note.vote.vote_option_blind;

bin/daod/src/example_contract/foo/validate.rs

@@ -9,7 +9,7 @@ use darkfi::{
 use std::any::{Any, TypeId};
 
 use crate::{
-    demo::{CallDataBase, StateRegistry, Transaction},
+    demo::{CallDataBase, StateRegistry, Transaction, UpdateBase},
     example_contract::state::State,
 };
 
@@ -53,7 +53,7 @@ pub fn state_transition(
     states: &StateRegistry,
     func_call_index: usize,
     parent_tx: &Transaction,
-) -> Result<Update> {
+) -> Result<Box<dyn UpdateBase>> {
     let func_call = &parent_tx.func_calls[func_call_index];
     let call_data = func_call.call_data.as_any();
 
@@ -69,7 +69,7 @@ pub fn state_transition(
         return Err(Error::ValueExists)
     }
 
-    Ok(Update { public_value: call_data.header.public_c })
+    Ok(Box::new(Update { public_value: call_data.header.public_c }))
 }
 
 #[derive(Clone)]
@@ -77,7 +77,12 @@ pub struct Update {
     public_value: pallas::Base,
 }
 
-pub fn apply(states: &mut StateRegistry, update: Update) {
-    let example_state = states.lookup_mut::<State>(&"Example".to_string()).unwrap();
-    example_state.add_public_value(update.public_value);
+impl UpdateBase for Update {
+    fn apply(self: Box<Self>, states: &mut StateRegistry) {
+        let example_state = states.lookup_mut::<State>(&"Example".to_string()).unwrap();
+        example_state.add_public_value(self.public_value);
+    }
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
 }

bin/daod/src/money_contract/transfer/validate.rs

@@ -60,6 +60,9 @@ impl UpdateBase for Update {
             state.wallet_cache.try_decrypt_note(coin, enc_note, &mut state.tree);
         }
     }
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
 }
 
 pub fn state_transition(