config to option, add new_empty on state

Author: sapinb

crates/cac/protocol/src/evaluator/state.rs

@@ -2,19 +2,30 @@ use std::collections::HashMap;
 
 use mosaic_cac_types::{DepositId, MsgId, Seed};
 
-use super::artifact::EvaluatorArtifactStore;
 use crate::evaluator::deposit::DepositState;
 
 #[derive(Debug)]
 #[expect(dead_code)]
-pub struct State<S: EvaluatorArtifactStore> {
-    pub(crate) config: Config,
+pub struct State<S> {
+    pub(crate) config: Option<Config>,
     pub(crate) context: Context,
     pub(crate) step: Step,
     pub(crate) deposits: HashMap<DepositId, DepositState>,
     pub(crate) artifact_store: S,
 }
 
+impl<S> State<S> {
+    pub fn new_empty(artifact_store: S) -> Self {
+        Self {
+            config: None,
+            context: Context::default(),
+            step: Step::Uninit,
+            deposits: HashMap::default(),
+            artifact_store,
+        }
+    }
+}
+
 /// Immutable state that is set during init and never updated
 #[derive(Debug)]
 #[expect(dead_code)]

crates/cac/protocol/src/garbler/state.rs

@@ -6,19 +6,31 @@ use mosaic_cac_types::{
 };
 use mosaic_common::constants::N_EVAL_CIRCUITS;
 
-use super::{artifact::GarblerArtifactStore, deposit::DepositState};
+use super::deposit::DepositState;
 
 #[derive(Debug)]
-pub struct State<S: GarblerArtifactStore> {
-    pub(crate) config: Config,
+pub struct State<S> {
+    pub(crate) config: Option<Config>,
     pub(crate) context: Context,
     pub(crate) step: Step,
     pub(crate) deposits: HashMap<DepositId, DepositState>,
     pub(crate) artifact_store: S,
 }
 
+impl<S> State<S> {
+    pub fn new_empty(artifact_store: S) -> Self {
+        Self {
+            config: None,
+            context: Context::default(),
+            step: Step::Uninit,
+            deposits: HashMap::new(),
+            artifact_store,
+        }
+    }
+}
+
 /// Immutable state that is set during init and never updated
-#[derive(Debug)]
+#[derive(Debug, Clone, Copy)]
 pub struct Config {
     pub(crate) seed: Seed,
     pub(crate) setup_inputs: SetupInputs,

crates/cac/protocol/src/garbler/stf.rs

@@ -27,14 +27,15 @@ pub(crate) async fn stf<S: GarblerArtifactStore>(
             match state.step {
                 Step::Uninit => {
                     // state update
-                    state.config = Config {
+                    state.config = Some(Config {
                         seed: data.seed,
                         setup_inputs: data.setup_inputs,
-                    };
+                    });
                     state.step = Step::GeneratingPolynomials;
 
                     // generate actions
-                    actions.push(Action::GeneratePolynomials(state.config.seed));
+                    let seed = state.config.expect("just set").seed;
+                    actions.push(Action::GeneratePolynomials(seed));
                 }
                 _ => return Err(SMError::UnexpectedInput),
             }
@@ -71,7 +72,8 @@ pub(crate) async fn stf<S: GarblerArtifactStore>(
                     state.step = Step::GeneratingTableCommitments;
 
                     // generate actions
-                    let seeds = generate_garbling_table_seeds(state.config.seed);
+                    let config = require_config(&state)?;
+                    let seeds = generate_garbling_table_seeds(config.seed);
                     actions.push(Action::GenerateTableCommitments(
                         Box::new(seeds),
                         input_shares,
@@ -135,13 +137,14 @@ pub(crate) async fn stf<S: GarblerArtifactStore>(
                             let msg_id = challenge_msg.id();
                             let (input_shares, output_shares) =
                                 state.artifact_store.load_shares().await?;
-                            let seeds = generate_garbling_table_seeds(state.config.seed);
+                            let config = require_config(&state)?;
+                            let seeds = generate_garbling_table_seeds(config.seed);
                             let challenge_response_msg = create_challenge_response_msg(
                                 challenge_msg.challenge_indices.as_ref(),
                                 input_shares,
                                 output_shares,
                                 seeds,
-                                state.config.setup_inputs,
+                                config.setup_inputs,
                             );
                             state
                                 .artifact_store
@@ -186,7 +189,8 @@ pub(crate) async fn stf<S: GarblerArtifactStore>(
                 let eval_commitments =
                     get_eval_commitments(&eval_indices, garbling_table_commitments.as_ref());
 
-                let garbling_seeds = generate_garbling_table_seeds(state.config.seed);
+                let config = require_config(&state)?;
+                let garbling_seeds = generate_garbling_table_seeds(config.seed);
                 let eval_seeds = get_eval_seeds(&eval_indices, &garbling_seeds);
 
                 state.step = Step::TransferringGarblingTables {
@@ -449,14 +453,16 @@ pub(crate) async fn restore<S: GarblerArtifactStore>(state: &State<S>) -> SMResu
     match &state.step {
         Step::Uninit => {}
         Step::GeneratingPolynomials => {
-            actions.push(Action::GeneratePolynomials(state.config.seed));
+            let config = require_config(state)?;
+            actions.push(Action::GeneratePolynomials(config.seed));
         }
         Step::GeneratingShares => {
             let polynomials = state.artifact_store.load_polynomials().await?;
             actions.push(Action::GenerateShares(polynomials));
         }
         Step::GeneratingTableCommitments => {
-            let seeds = generate_garbling_table_seeds(state.config.seed);
+            let config = require_config(state)?;
+            let seeds = generate_garbling_table_seeds(config.seed);
             let (input_shares, output_shares) = state.artifact_store.load_shares().await?;
             actions.push(Action::GenerateTableCommitments(
                 Box::new(seeds),
@@ -485,13 +491,14 @@ pub(crate) async fn restore<S: GarblerArtifactStore>(state: &State<S>) -> SMResu
             };
             let challenge_indices = state.artifact_store.load_challenge_indices().await?;
             let (input_shares, output_shares) = state.artifact_store.load_shares().await?;
-            let seeds = generate_garbling_table_seeds(state.config.seed);
+            let config = require_config(state)?;
+            let seeds = generate_garbling_table_seeds(config.seed);
             let challenge_response_msg = create_challenge_response_msg(
                 challenge_indices.as_ref(),
                 input_shares,
                 output_shares,
                 seeds,
-                state.config.setup_inputs,
+                config.setup_inputs,
             );
 
             // sanity check
@@ -610,6 +617,12 @@ pub(crate) async fn restore<S: GarblerArtifactStore>(state: &State<S>) -> SMResu
     Ok(actions)
 }
 
+fn require_config<S>(state: &State<S>) -> SMResult<Config> {
+    state
+        .config
+        .ok_or_else(|| SMError::StateInconsistency("expected config to not be None"))
+}
+
 #[expect(unused_variables)]
 fn generate_garbling_table_seeds(base_seed: Seed) -> AllGarblingSeeds {
     todo!()