feat: move state mutations and transient data inline

Author: freesig

crates/check/benches/check_intents.rs

@@ -10,7 +10,7 @@ use essential_state_read_vm as state_read_vm;
 use essential_state_read_vm::StateRead;
 use essential_types::{
     intent::{Directive, Intent},
-    solution::{Mutation, Mutations, Solution, SolutionData},
+    solution::{Mutation, Solution, SolutionData},
     ContentAddress, IntentAddress, Key, Signed, Word,
 };
 use secp256k1::{PublicKey, Secp256k1, SecretKey};
@@ -145,15 +145,13 @@ impl State {
 
     /// Apply all mutations proposed by the given solution.
     pub fn apply_mutations(&mut self, solution: &Solution) {
-        for state_mutation in &solution.state_mutations {
-            let set = &solution
-                .data
-                .get(state_mutation.pathway as usize)
-                .expect("intent pathway not found in solution data")
-                .intent_to_solve
-                .set;
-            for mutation in state_mutation.mutations.iter() {
-                self.set(set.clone(), &mutation.key, mutation.value.clone());
+        for data in &solution.data {
+            for mutation in &data.state_mutations {
+                self.set(
+                    data.intent_to_solve.set.clone(),
+                    &mutation.key,
+                    mutation.value.clone(),
+                );
             }
         }
     }
@@ -250,24 +248,15 @@ fn test_intent_42_solution_pair(
                 intent: ContentAddress(essential_hash::hash(intents.data.get(i).unwrap())),
             },
             decision_variables: vec![42],
-        })
-        .collect();
-
-    let state_mutations = (0..amount)
-        .map(|i| Mutations {
-            pathway: i as u16,
-            mutations: vec![Mutation {
+            state_mutations: vec![Mutation {
                 key: vec![0, 0, 0, 0],
                 value: vec![42],
             }],
+            transient_data: vec![],
         })
         .collect();
 
-    let solution = Solution {
-        data,
-        transient_data: vec![],
-        state_mutations,
-    };
+    let solution = Solution { data };
 
     (intents, solution)
 }

crates/check/src/solution.rs

@@ -229,29 +229,19 @@ pub fn check_data(data_slice: &[SolutionData]) -> Result<(), InvalidSolutionData
 pub fn check_state_mutations(solution: &Solution) -> Result<(), InvalidStateMutations> {
     // Validate state mutations.
     // Ensure that solution state mutations length is below limit length.
-    if solution.state_mutations.len() > MAX_STATE_MUTATIONS {
+    if solution.state_mutations_len() > MAX_STATE_MUTATIONS {
         return Err(InvalidStateMutations::TooMany(
-            solution.state_mutations.len(),
+            solution.state_mutations_len(),
         ));
     }
 
-    // Ensure that all state mutations with a pathway points to some solution data.
-    for state_mut in &solution.state_mutations {
-        if solution.data.len() <= usize::from(state_mut.pathway) {
-            return Err(InvalidStateMutations::PathwayOutOfRangeOfSolutionData(
-                state_mut.pathway,
-            ));
-        }
-    }
-
     // Ensure that no more than one mutation per slot is proposed.
-    let mut mut_keys = HashSet::new();
-    for state_mutation in &solution.state_mutations {
-        let intent_addr = &solution.data[state_mutation.pathway as usize].intent_to_solve;
-        for mutation in &state_mutation.mutations {
-            if !mut_keys.insert((intent_addr, &mutation.key)) {
+    for data in &solution.data {
+        let mut mut_keys = HashSet::new();
+        for mutation in &data.state_mutations {
+            if !mut_keys.insert(&mutation.key) {
                 return Err(InvalidStateMutations::MultipleMutationsForSlot(
-                    intent_addr.clone(),
+                    data.intent_to_solve.clone(),
                     mutation.key.clone(),
                 ));
             }
@@ -265,17 +255,8 @@ pub fn check_state_mutations(solution: &Solution) -> Result<(), InvalidStateMuta
 pub fn check_transient_data(solution: &Solution) -> Result<(), InvalidTransientData> {
     // Validate transient data.
     // Ensure that solution transient data length is below limit length.
-    if solution.transient_data.len() > MAX_TRANSIENT_DATA {
-        return Err(InvalidTransientData::TooMany(solution.transient_data.len()));
-    }
-
-    // Ensure that all transient data with a pathway points to some solution data.
-    for transient_datum in &solution.transient_data {
-        if solution.data.len() <= usize::from(transient_datum.pathway) {
-            return Err(InvalidTransientData::PathwayOutOfRangeOfSolutionData(
-                transient_datum.pathway,
-            ));
-        }
+    if solution.transient_data_len() > MAX_TRANSIENT_DATA {
+        return Err(InvalidTransientData::TooMany(solution.transient_data_len()));
     }
 
     Ok(())

crates/check/tests/solution.rs

@@ -4,8 +4,8 @@ use essential_constraint_vm as constraint_vm;
 use essential_state_read_vm as state_read_vm;
 use essential_types::{
     intent::{Directive, Intent},
-    solution::{Mutation, Mutations, Solution, SolutionData},
-    ContentAddress, IntentAddress,
+    solution::{Mutation, Solution, SolutionData},
+    ContentAddress, IntentAddress, Word,
 };
 use std::sync::Arc;
 use util::{empty_solution, intent_addr, random_keypair, State};
@@ -23,13 +23,15 @@ fn test_solution_data() -> SolutionData {
     SolutionData {
         intent_to_solve: test_intent_addr(),
         decision_variables: vec![],
+        state_mutations: vec![],
+        transient_data: vec![],
     }
 }
 
-fn test_state_mutation() -> Mutations {
-    Mutations {
-        pathway: 0,
-        mutations: vec![],
+fn test_mutation(salt: usize) -> Mutation {
+    Mutation {
+        key: vec![salt as Word; 4],
+        value: vec![42],
     }
 }
 
@@ -48,7 +50,6 @@ fn too_many_solution_data() {
         data: (0..solution::MAX_SOLUTION_DATA + 1)
             .map(|_| test_solution_data())
             .collect(),
-        ..empty_solution()
     };
     assert!(matches!(
         solution::check(&solution).unwrap_err(),
@@ -63,8 +64,9 @@ fn too_many_decision_variables() {
         data: vec![SolutionData {
             intent_to_solve: test_intent_addr(),
             decision_variables: vec![0; (solution::MAX_DECISION_VARIABLES + 1) as usize],
+            state_mutations: vec![],
+            transient_data: vec![],
         }],
-        ..empty_solution()
     };
     assert!(matches!(
         solution::check(&solution).unwrap_err(),
@@ -76,9 +78,14 @@ fn too_many_decision_variables() {
 #[test]
 fn too_many_state_mutations() {
     let solution = Solution {
-        data: vec![test_solution_data()],
-        transient_data: vec![],
-        state_mutations: vec![test_state_mutation(); solution::MAX_STATE_MUTATIONS + 1],
+        data: vec![SolutionData {
+            intent_to_solve: test_intent_addr(),
+            decision_variables: vec![],
+            state_mutations: (0..(solution::MAX_STATE_MUTATIONS + 1))
+                .map(test_mutation)
+                .collect(),
+            transient_data: vec![],
+        }],
     };
     assert!(matches!(
         solution::check(&solution).unwrap_err(),
@@ -87,39 +94,20 @@ fn too_many_state_mutations() {
     ));
 }
 
-#[test]
-fn state_mutation_pathways_must_have_associated_solution_data() {
-    let solution = Solution {
-        state_mutations: vec![Mutations {
-            // Note: pathway out of bounds of solution data to trigger error.
-            pathway: 1,
-            mutations: Default::default(),
-        }],
-        transient_data: vec![],
-        data: vec![test_solution_data()],
-    };
-    assert!(matches!(
-        solution::check(&solution).unwrap_err(),
-        solution::InvalidSolution::StateMutations(
-            solution::InvalidStateMutations::PathwayOutOfRangeOfSolutionData(1)
-        ),
-    ));
-}
-
 #[test]
 fn multiple_mutations_for_slot() {
     let solution = Solution {
-        data: vec![test_solution_data()],
-        transient_data: vec![],
-        state_mutations: vec![Mutations {
-            pathway: 0,
-            mutations: vec![
+        data: vec![SolutionData {
+            intent_to_solve: test_intent_addr(),
+            decision_variables: vec![],
+            state_mutations: vec![
                 Mutation {
                     key: vec![0; 4],
                     value: vec![42],
                 };
                 2
             ],
+            transient_data: vec![],
         }],
     };
     assert!(matches!(
@@ -132,9 +120,14 @@ fn multiple_mutations_for_slot() {
 #[test]
 fn too_many_transient_data() {
     let solution = Solution {
-        data: vec![test_solution_data()],
-        transient_data: vec![test_state_mutation(); solution::MAX_TRANSIENT_DATA + 1],
-        state_mutations: vec![],
+        data: vec![SolutionData {
+            intent_to_solve: test_intent_addr(),
+            decision_variables: vec![],
+            state_mutations: vec![],
+            transient_data: (0..(solution::MAX_TRANSIENT_DATA + 1))
+                .map(test_mutation)
+                .collect(),
+        }],
     };
     assert!(matches!(
         solution::check(&solution).unwrap_err(),
@@ -143,25 +136,6 @@ fn too_many_transient_data() {
     ));
 }
 
-#[test]
-fn transient_data_pathways_must_have_associated_solution_data() {
-    let solution = Solution {
-        state_mutations: vec![],
-        transient_data: vec![Mutations {
-            // Note: pathway out of bounds of solution data to trigger error.
-            pathway: 1,
-            mutations: Default::default(),
-        }],
-        data: vec![test_solution_data()],
-    };
-    assert!(matches!(
-        solution::check(&solution).unwrap_err(),
-        solution::InvalidSolution::TransientData(
-            solution::InvalidTransientData::PathwayOutOfRangeOfSolutionData(1)
-        ),
-    ));
-}
-
 // Tests an intent for setting slot 0 to 42 against its associated solution.
 #[tokio::test]
 async fn check_intent_42_with_solution() {
@@ -296,11 +270,7 @@ async fn intent_with_multiple_state_reads_and_slots() {
         data: vec![SolutionData {
             intent_to_solve: intent_addr,
             decision_variables: Default::default(),
-        }],
-        transient_data: vec![],
-        state_mutations: vec![Mutations {
-            pathway: 0,
-            mutations: vec![
+            state_mutations: vec![
                 Mutation {
                     key: vec![0],
                     value: vec![0, 1, 2, 3, 4],
@@ -322,6 +292,7 @@ async fn intent_with_multiple_state_reads_and_slots() {
                     value: vec![8],
                 },
             ],
+            transient_data: vec![],
         }],
     };
 

crates/check/tests/util.rs

@@ -5,7 +5,7 @@ use essential_check::{
     state_read_vm::StateRead,
     types::{
         intent::{Directive, Intent},
-        solution::{Mutation, Mutations, Solution, SolutionData},
+        solution::{Mutation, Solution, SolutionData},
         ContentAddress, IntentAddress, Key, Signed, Word,
     },
 };
@@ -94,15 +94,13 @@ impl State {
 
     /// Apply all mutations proposed by the given solution.
     pub fn apply_mutations(&mut self, solution: &Solution) {
-        for state_mutation in &solution.state_mutations {
-            let set = &solution
-                .data
-                .get(state_mutation.pathway as usize)
-                .expect("intent pathway not found in solution data")
-                .intent_to_solve
-                .set;
-            for mutation in state_mutation.mutations.iter() {
-                self.set(set.clone(), &mutation.key, mutation.value.clone());
+        for data in &solution.data {
+            for mutation in data.state_mutations.iter() {
+                self.set(
+                    data.intent_to_solve.set.clone(),
+                    &mutation.key,
+                    mutation.value.clone(),
+                );
             }
         }
     }
@@ -126,8 +124,6 @@ impl StateRead for State {
 pub fn empty_solution() -> Solution {
     Solution {
         data: Default::default(),
-        transient_data: Default::default(),
-        state_mutations: Default::default(),
     }
 }
 
@@ -217,14 +213,11 @@ pub fn test_intent_42_solution_pair(
         data: vec![SolutionData {
             intent_to_solve: intent_addr,
             decision_variables,
-        }],
-        transient_data: vec![],
-        state_mutations: vec![Mutations {
-            pathway: 0,
-            mutations: vec![Mutation {
+            state_mutations: vec![Mutation {
                 key: vec![0, 0, 0, 0],
                 value: vec![42],
             }],
+            transient_data: vec![],
         }],
     };
 

crates/constraint-vm/benches/eval.rs

@@ -17,6 +17,8 @@ pub fn bench(c: &mut Criterion) {
                     intent: ContentAddress([0; 32]),
                 },
                 decision_variables: vec![],
+                state_mutations: vec![],
+                transient_data: vec![],
             }],
             index: 0,
             mutable_keys: &mutable_keys,