add special case inputs for init and restore

Author: sapinb

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

@@ -72,7 +72,7 @@ pub(crate) async fn stf<S: GarblerArtifactStore>(
                     state.step = Step::GeneratingTableCommitments;
 
                     // generate actions
-                    let config = require_config(&state)?;
+                    let config = require_config(state)?;
                     let seeds = generate_garbling_table_seeds(config.seed);
                     actions.push(Action::GenerateTableCommitments(
                         Box::new(seeds),
@@ -137,7 +137,7 @@ 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 config = require_config(&state)?;
+                            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(),
@@ -189,7 +189,7 @@ pub(crate) async fn stf<S: GarblerArtifactStore>(
                 let eval_commitments =
                     get_eval_commitments(&eval_indices, garbling_table_commitments.as_ref());
 
-                let config = require_config(&state)?;
+                let config = require_config(state)?;
                 let garbling_seeds = generate_garbling_table_seeds(config.seed);
                 let eval_seeds = get_eval_seeds(&eval_indices, &garbling_seeds);
 

crates/state-machine/executor/src/evaluator.rs

@@ -6,7 +6,7 @@ use mosaic_cac_protocol::evaluator::{
 };
 use mosaic_cac_types::state_machine::{
     StateMachineId,
-    evaluator::{ActionContainer, Input},
+    evaluator::{ActionContainer, EvaluatorInitData, Input},
 };
 
 use crate::{Db, ExecutorError, ExecutorResult};
@@ -33,6 +33,23 @@ pub(crate) async fn handle_evaluator_input<D: Db>(
     Ok(actions)
 }
 
+#[expect(unused_variables)]
+pub(crate) async fn handle_evaluator_init<D: Db>(
+    sm_id: StateMachineId,
+    init_data: EvaluatorInitData,
+    db: Arc<D>,
+) -> ExecutorResult<ActionContainer> {
+    unimplemented!()
+}
+
+#[expect(unused_variables)]
+pub(crate) async fn handle_evaluator_restore<D: Db>(
+    sm_id: StateMachineId,
+    db: Arc<D>,
+) -> ExecutorResult<ActionContainer> {
+    unimplemented!()
+}
+
 #[derive(Debug, Default)]
 struct SaveCache {}
 

crates/state-machine/executor/src/garbler.rs

@@ -9,7 +9,7 @@ use mosaic_cac_types::{
     AllPolynomialCommitments, AllPolynomials, InputShares, OutputShares,
     state_machine::{
         StateMachineId,
-        garbler::{ActionContainer, Input},
+        garbler::{ActionContainer, GarblerInitData, Input},
     },
 };
 
@@ -37,6 +37,50 @@ pub(crate) async fn handle_garbler_input<D: Db>(
     Ok(actions)
 }
 
+pub(crate) async fn handle_garbler_restore<D: Db>(
+    sm_id: StateMachineId,
+    db: Arc<D>,
+) -> ExecutorResult<ActionContainer> {
+    let state = load_garbler_state(sm_id, db.clone()).await?;
+
+    let mut actions = vec![];
+
+    GarblerSM::<GarblerArtifactStoreImpl<D>>::restore(&state, &mut actions)
+        .await
+        .map_err(|err| ExecutorError::StateMachine(Box::new(err)))?;
+
+    Ok(actions)
+}
+
+pub(crate) async fn handle_garbler_init<D: Db>(
+    sm_id: StateMachineId,
+    init_data: GarblerInitData,
+    db: Arc<D>,
+) -> ExecutorResult<ActionContainer> {
+    let mut state = init_garbler_state(sm_id, db.clone());
+
+    let mut actions = vec![];
+    let input = FasmInput::Normal(Input::Init(init_data));
+
+    GarblerSM::<GarblerArtifactStoreImpl<D>>::stf(&mut state, input, &mut actions)
+        .await
+        .map_err(|err| ExecutorError::StateMachine(Box::new(err)))?;
+
+    Ok(actions)
+}
+
+fn init_garbler_state<D: Db>(
+    sm_id: StateMachineId,
+    db: Arc<D>,
+) -> State<GarblerArtifactStoreImpl<D>> {
+    let artifact_store = GarblerArtifactStoreImpl {
+        sm_id,
+        saved: Default::default(),
+        db,
+    };
+    State::new_empty(artifact_store)
+}
+
 #[expect(unused_variables)]
 async fn load_garbler_state<D: Db>(
     sm_id: StateMachineId,
@@ -54,7 +98,7 @@ async fn save_garbler_state<D: Db>(
     todo!()
 }
 
-#[derive(Debug)]
+#[derive(Debug, Default)]
 #[expect(dead_code)]
 struct SaveCache {
     polynomials: Option<Box<AllPolynomials>>,

crates/state-machine/executor/src/lib.rs

@@ -11,19 +11,32 @@ use db::Db;
 pub use error::{ExecutorError, ExecutorResult};
 use mosaic_cac_types::state_machine::{
     StateMachineId,
-    evaluator::{ActionContainer as EvaluatorActionContainer, Input as EvaluatorInput},
-    garbler::{ActionContainer as GarblerActionContainer, Input as GarblerInput},
+    evaluator::{
+        ActionContainer as EvaluatorActionContainer, EvaluatorInitData, Input as EvaluatorInput,
+    },
+    garbler::{ActionContainer as GarblerActionContainer, GarblerInitData, Input as GarblerInput},
 };
 
-use crate::{evaluator::handle_evaluator_input, garbler::handle_garbler_input};
+use crate::{
+    evaluator::{handle_evaluator_init, handle_evaluator_input, handle_evaluator_restore},
+    garbler::{handle_garbler_init, handle_garbler_input, handle_garbler_restore},
+};
 
 /// All possible state machine inputs
 #[derive(Debug)]
 pub enum Input {
     /// Garbler SM inputs
     Garbler(GarblerInput),
+    /// Special case to initialize garbler state machine
+    GarblerInit(GarblerInitData),
+    /// Restore state machine and re-dispatch actions.
+    GarblerRestore,
     /// Evaluator SM inputs
     Evaluator(EvaluatorInput),
+    /// Special case to initialize evaluator state machine
+    EvaluatorInit(EvaluatorInitData),
+    /// Restore state machine and re-dispatch actions.
+    EvaluatorRestore,
 }
 
 /// Input to state machine executor, consisiting of state machine id and input to state machine.
@@ -59,14 +72,35 @@ pub async fn sm_executor<D: Db>(
     ex_input: ExecutorInput,
     db: Arc<D>,
 ) -> ExecutorResult<ActionContainer> {
+    let sm_id = ex_input.sm_id;
     let actions = match ex_input.sm_input {
         Input::Garbler(input) => {
-            let actions = handle_garbler_input(ex_input.sm_id, input, db.clone()).await?;
+            let actions = handle_garbler_input(sm_id, input, db).await?;
+
+            ActionContainer::Garbler(actions)
+        }
+        Input::GarblerInit(init_data) => {
+            let actions = handle_garbler_init(sm_id, init_data, db).await?;
+
+            ActionContainer::Garbler(actions)
+        }
+        Input::GarblerRestore => {
+            let actions = handle_garbler_restore(sm_id, db).await?;
 
             ActionContainer::Garbler(actions)
         }
         Input::Evaluator(input) => {
-            let actions = handle_evaluator_input(ex_input.sm_id, input, db.clone()).await?;
+            let actions = handle_evaluator_input(sm_id, input, db).await?;
+
+            ActionContainer::Evaluator(actions)
+        }
+        Input::EvaluatorInit(init_data) => {
+            let actions = handle_evaluator_init(sm_id, init_data, db).await?;
+
+            ActionContainer::Evaluator(actions)
+        }
+        Input::EvaluatorRestore => {
+            let actions = handle_evaluator_restore(sm_id, db).await?;
 
             ActionContainer::Evaluator(actions)
         }