more breakdown of garbler actions

sapinb · sapinb · commit d5daee1746e7 · 2026-01-27T14:28:13.000+05:45
diff --git a/crates/cac/protocol/src/garbler/artifact.rs b/crates/cac/protocol/src/garbler/artifact.rs
@@ -1,7 +1,8 @@
 use mosaic_cac_types::{
     AllGarblingTableCommitments, AllPolynomialCommitments, AllPolynomials, ChallengeIndices,
-    CompletedSignatures, DepositAdaptors, DepositId, DepositInputs, InputShares, OutputShares,
-    ReservedInputShares, Sighashes, WithdrawalAdaptors, WithdrawalInputs,
+    CircuitInputShares, CircuitOutputShare, CompletedSignatures, DepositAdaptors, DepositId,
+    DepositInputs, GarblingTableCommitment, Index, InputShares, OutputShares, ReservedInputShares,
+    Sighashes, WithdrawalAdaptors, WithdrawalInputs,
 };
 
 use crate::SMResult;
@@ -21,21 +22,27 @@ pub trait GarblerArtifactStore: Sized {
         &self,
     ) -> impl Future<Output = SMResult<AllPolynomialCommitments>>;
 
-    fn save_shares(
+    fn save_shares_for_index(
         &mut self,
-        input_shares: &InputShares,
-        output_shares: &OutputShares,
+        index: Index,
+        input_shares: &CircuitInputShares,
+        output_shares: &CircuitOutputShare,
     ) -> impl Future<Output = SMResult<()>>;
     fn load_shares(&self) -> impl Future<Output = SMResult<(Box<InputShares>, Box<OutputShares>)>>;
     fn load_reserved_input_shares(
         &self,
     ) -> impl Future<Output = SMResult<Box<ReservedInputShares>>>;
 
-    fn save_garbling_table_commitments(
+    fn save_garbling_table_commitment(
         &mut self,
-        commitments: &AllGarblingTableCommitments,
+        index: Index,
+        commitments: &GarblingTableCommitment,
     ) -> impl Future<Output = SMResult<()>>;
-    fn load_garbling_table_commitments(
+    fn load_garbling_table_commitment(
+        &mut self,
+        index: Index,
+    ) -> impl Future<Output = SMResult<GarblingTableCommitment>>;
+    fn load_all_garbling_table_commitments(
         &self,
     ) -> impl Future<Output = SMResult<Box<AllGarblingTableCommitments>>>;
 
diff --git a/crates/cac/protocol/src/garbler/state.rs b/crates/cac/protocol/src/garbler/state.rs
@@ -2,9 +2,10 @@ use std::collections::HashMap;
 
 use bitvec::BitArr;
 use mosaic_cac_types::{
-    DepositId, EvalGarblingSeeds, EvalGarblingTableCommitments, MsgId, Seed, SetupInputs,
+    AllGarblingSeeds, DepositId, EvalGarblingSeeds, EvalGarblingTableCommitments, MsgId, Seed,
+    SetupInputs,
 };
-use mosaic_common::constants::N_EVAL_CIRCUITS;
+use mosaic_common::constants::{N_CIRCUITS, N_EVAL_CIRCUITS};
 
 use super::deposit::DepositState;
 
@@ -55,14 +56,16 @@ pub enum Step {
     #[default]
     /// Not initialized; Default
     Uninit,
-    /// Initialized, start generating polynomial commitments
-    GeneratingPolynomials,
     /// Polynomials generated.
+    GeneratingPolynomialCommitments,
     /// Generate shares for all tables.
-    GeneratingShares,
+    GeneratingShares { generated: BitArr!(for N_CIRCUITS) },
     /// Dispatch actions to generate commitments.
     /// Wait for all table commitments to be provided.
-    GeneratingTableCommitments,
+    GeneratingTableCommitments {
+        seeds: Box<AllGarblingSeeds>,
+        generated: BitArr!(for N_CIRCUITS),
+    },
     /// Got table commitments, send commit msg.
     /// Wait for commit msg ack.
     SendingCommit,
diff --git a/crates/cac/protocol/src/garbler/stf.rs b/crates/cac/protocol/src/garbler/stf.rs
@@ -1,14 +1,15 @@
 use bitvec::array::BitArray;
 use mosaic_cac_types::{
-    AdaptorMsg, AllGarblingSeeds, AllGarblingTableCommitments, ChallengeIndices, ChallengeMsg,
-    ChallengeResponseMsg, CommitMsg, EvalGarblingSeeds, EvalGarblingTableCommitments,
-    EvaluationIndices, HasMsgId, InputShares, OutputShares, ReservedDepositInputShares,
+    AdaptorMsg, AllGarblingSeeds, AllGarblingTableCommitments, AllPolynomials, ChallengeIndices,
+    ChallengeMsg, ChallengeResponseMsg, CommitMsg, EvalGarblingSeeds, EvalGarblingTableCommitments,
+    EvaluationIndices, HasMsgId, Index, InputShares, OutputShares, ReservedDepositInputShares,
     ReservedInputShares, ReservedWithdrawalInputShares, Seed, SetupInputs,
     state_machine::garbler::{
         Action, AdaptorVerificationData, CompleteAdaptorSignaturesData, GarblerDepositInitData,
         Input,
     },
 };
+use mosaic_common::constants::N_CIRCUITS;
 
 use super::{
     artifact::GarblerArtifactStore,
@@ -31,73 +32,114 @@ pub(crate) async fn stf<S: GarblerArtifactStore>(
                         seed: data.seed,
                         setup_inputs: data.setup_inputs,
                     });
-                    state.step = Step::GeneratingPolynomials;
 
-                    // generate actions
-                    let seed = state.config.expect("just set").seed;
-                    actions.push(Action::GeneratePolynomials(seed));
+                    let polynomials = generate_polynomials(data.seed);
+
+                    state.artifact_store.save_polynomials(&polynomials).await?;
+                    state.step = Step::GeneratingPolynomialCommitments;
+
+                    // Get polynomials directly from db
+                    actions.push(Action::GeneratePolynomialCommitments);
                 }
                 _ => return Err(SMError::UnexpectedInput),
             }
         }
-        Input::PolynomialsGenerated(polynomials, commitments) => {
+        Input::PolynomialCommitmentsGenerated(commitments) => {
             match state.step {
-                Step::GeneratingPolynomials => {
+                Step::GeneratingPolynomialCommitments => {
                     // state update
-                    state.artifact_store.save_polynomials(&polynomials).await?;
                     state
                         .artifact_store
                         .save_polynomial_commitments(&commitments)
                         .await?;
-                    state.step = Step::GeneratingShares;
+                    state.step = Step::GeneratingShares {
+                        generated: BitArray::ZERO,
+                    };
 
                     // generate actions
-                    actions.push(Action::GenerateShares(polynomials));
+                    for idx in 0..N_CIRCUITS {
+                        let index = Index::new(idx + 1).expect("valid index");
+                        actions.push(Action::GenerateShares(index));
+                    }
                 }
                 _ => return Err(SMError::UnexpectedInput),
             }
         }
-        Input::SharesGenerated(input_shares, output_shares) => {
-            match state.step {
-                Step::GeneratingShares => {
+        Input::SharesGenerated(index, input_shares, output_shares) => {
+            match &mut state.step {
+                Step::GeneratingShares { generated } => {
+                    let idx = index.get().checked_sub(1).ok_or_else(|| {
+                        // not expecting reserved (0) index
+                        SMError::InvalidInputData
+                    })?;
+                    if generated[idx] {
+                        // already have this data
+                        return Err(SMError::InvalidInputData);
+                    }
+
                     // state update
+                    generated.set(idx, true);
                     state
                         .artifact_store
-                        .save_shares(input_shares.as_ref(), output_shares.as_ref())
+                        .save_shares_for_index(index, input_shares.as_ref(), output_shares.as_ref())
                         .await?;
 
-                    state.step = Step::GeneratingTableCommitments;
+                    if generated.all() {
+                        let config = require_config(state)?;
+                        let seeds = Box::new(generate_garbling_table_seeds(config.seed));
 
-                    // generate actions
-                    let config = require_config(state)?;
-                    let seeds = generate_garbling_table_seeds(config.seed);
-                    actions.push(Action::GenerateTableCommitments(
-                        Box::new(seeds),
-                        input_shares,
-                        output_shares,
-                    ));
+                        // generate actions
+                        for idx in 0..N_CIRCUITS {
+                            let index = Index::new(idx + 1).expect("valid index");
+                            let seed = seeds[idx];
+                            actions.push(Action::GenerateTableCommitment(index, seed));
+                        }
+
+                        state.step = Step::GeneratingTableCommitments {
+                            seeds,
+                            generated: BitArray::ZERO,
+                        };
+                    }
                 }
                 _ => return Err(SMError::UnexpectedInput),
             }
         }
-        Input::TableCommitmentsGenerated(garbling_table_commitments) => {
-            match state.step {
-                Step::GeneratingTableCommitments => {
+        Input::TableCommitmentGenerated(index, commitment) => {
+            match &mut state.step {
+                Step::GeneratingTableCommitments { generated, .. } => {
+                    let idx = index.get().checked_sub(1).ok_or_else(|| {
+                        // not expecting reserved (0) index
+                        SMError::InvalidInputData
+                    })?;
+                    if generated[idx] {
+                        // already have this data
+                        return Err(SMError::InvalidInputData);
+                    }
+
                     // state update
+                    generated.set(idx, true);
                     state
                         .artifact_store
-                        .save_garbling_table_commitments(garbling_table_commitments.as_ref())
+                        .save_garbling_table_commitment(index, &commitment)
                         .await?;
-                    state.step = Step::SendingCommit;
 
-                    // generate actions
-                    let polynomial_commitments =
-                        state.artifact_store.load_polynomial_commitments().await?;
-                    let commit_msg = CommitMsg {
-                        polynomial_commitments,
-                        garbling_table_commitments,
-                    };
-                    actions.push(Action::SendCommitMsg(commit_msg));
+                    if generated.all() {
+                        state.step = Step::SendingCommit;
+
+                        // generate actions
+                        let polynomial_commitments =
+                            state.artifact_store.load_polynomial_commitments().await?;
+                        let garbling_table_commitments = state
+                            .artifact_store
+                            .load_all_garbling_table_commitments()
+                            .await?;
+                        let commit_msg = CommitMsg {
+                            polynomial_commitments,
+                            garbling_table_commitments,
+                        };
+                        actions.push(Action::SendCommitMsg(commit_msg));
+                    }
+                    // else stay on same step and wait for all table commitments to be generated
                 }
                 _ => return Err(SMError::UnexpectedInput),
             }
@@ -181,24 +223,26 @@ pub(crate) async fn stf<S: GarblerArtifactStore>(
 
                 let garbling_table_commitments = state
                     .artifact_store
-                    .load_garbling_table_commitments()
+                    .load_all_garbling_table_commitments()
                     .await?;
-                let eval_commitments =
-                    get_eval_commitments(&eval_indices, garbling_table_commitments.as_ref());
+                let eval_commitments = Box::new(get_eval_commitments(
+                    &eval_indices,
+                    garbling_table_commitments.as_ref(),
+                ));
 
                 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 {
-                    eval_seeds: Box::new(eval_seeds),
-                    eval_commitments: Box::new(eval_commitments),
-                    transferred: BitArray::ZERO,
-                };
+                let eval_seeds = Box::new(get_eval_seeds(&eval_indices, &garbling_seeds));
 
                 for seed in eval_seeds.as_ref() {
                     actions.push(Action::TransferGarblingTable(*seed));
                 }
+
+                state.step = Step::TransferringGarblingTables {
+                    eval_seeds,
+                    eval_commitments,
+                    transferred: BitArray::ZERO,
+                };
             }
             _ => return Err(SMError::UnexpectedInput),
         },
@@ -449,29 +493,33 @@ pub(crate) async fn restore<S: GarblerArtifactStore>(state: &State<S>) -> SMResu
 
     match &state.step {
         Step::Uninit => {}
-        Step::GeneratingPolynomials => {
-            let config = require_config(state)?;
-            actions.push(Action::GeneratePolynomials(config.seed));
+        Step::GeneratingPolynomialCommitments => {
+            actions.push(Action::GeneratePolynomialCommitments);
         }
-        Step::GeneratingShares => {
-            let polynomials = state.artifact_store.load_polynomials().await?;
-            actions.push(Action::GenerateShares(polynomials));
+        Step::GeneratingShares { generated } => {
+            for idx in 0..N_CIRCUITS {
+                if generated[idx] {
+                    continue;
+                }
+                let index = Index::new(idx + 1).expect("valid index");
+                actions.push(Action::GenerateShares(index));
+            }
         }
-        Step::GeneratingTableCommitments => {
-            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),
-                input_shares,
-                output_shares,
-            ));
+        Step::GeneratingTableCommitments { seeds, generated } => {
+            for idx in 0..N_CIRCUITS {
+                if generated[idx] {
+                    continue;
+                }
+                let index = Index::new(idx + 1).expect("valid index");
+                let seed = seeds[idx];
+                actions.push(Action::GenerateTableCommitment(index, seed));
+            }
         }
         Step::SendingCommit => {
             let polynomial_commitments = state.artifact_store.load_polynomial_commitments().await?;
             let garbling_table_commitments = state
                 .artifact_store
-                .load_garbling_table_commitments()
+                .load_all_garbling_table_commitments()
                 .await?;
             let commit_msg = CommitMsg {
                 polynomial_commitments,
@@ -621,6 +669,11 @@ fn require_config<S>(state: &State<S>) -> SMResult<&Config> {
         .ok_or_else(|| SMError::StateInconsistency("expected config to not be None"))
 }
 
+#[expect(unused_variables)]
+fn generate_polynomials(seed: Seed) -> AllPolynomials {
+    todo!()
+}
+
 #[expect(unused_variables)]
 fn generate_garbling_table_seeds(base_seed: Seed) -> AllGarblingSeeds {
     todo!()
diff --git a/crates/cac/types/src/state_machine/garbler/action.rs b/crates/cac/types/src/state_machine/garbler/action.rs
@@ -1,27 +1,22 @@
 use fasm::actions::TrackedActionTypes;
+use mosaic_vs3::Index;
 
 use crate::{
-    AllGarblingSeeds, AllPolynomials, ChallengeResponseMsg, CommitMsg, DepositAdaptors, DepositId,
-    GarblingSeed, InputShares, MsgId, OutputShares, PubKey, ReservedDepositInputShares,
-    ReservedWithdrawalInputShares, Seed, Sighashes, WithdrawalAdaptors, WithdrawalInputs,
+    ChallengeResponseMsg, CommitMsg, DepositAdaptors, DepositId, GarblingSeed, InputShares, MsgId,
+    PubKey, ReservedDepositInputShares, ReservedWithdrawalInputShares, Sighashes,
+    WithdrawalAdaptors, WithdrawalInputs,
 };
 
 /// Actions emitted by the garbler state machine for external execution.
 #[derive(Debug, PartialEq, Eq)]
 #[non_exhaustive]
 pub enum Action {
     /// Generate polynomials from the base seed.
-    GeneratePolynomials(Seed),
+    GeneratePolynomialCommitments,
     /// Generate input/output shares from polynomials.
-    GenerateShares(AllPolynomials),
-    // /// Generate single table's garbling table commitment from seeds and shares.
-    // GenerateTableCommitment(
-    //     GarblingSeed,
-    //     Box<CircuitInputShares>,
-    //     Box<CircuitOutputShare>,
-    // ),
-    /// Generate garbling table commitments from seeds and shares.
-    GenerateTableCommitments(Box<AllGarblingSeeds>, Box<InputShares>, Box<OutputShares>),
+    GenerateShares(Index),
+    /// Generate single table's garbling table commitment from seeds and shares.
+    GenerateTableCommitment(Index, GarblingSeed),
     /// Send commit message with polynomial and table commitments to evaluator.
     SendCommitMsg(CommitMsg),
     /// Acknowledge receipt of challenge message from evaluator.
diff --git a/crates/cac/types/src/state_machine/garbler/input.rs b/crates/cac/types/src/state_machine/garbler/input.rs
diff --git a/crates/state-machine/executor/src/garbler.rs b/crates/state-machine/executor/src/garbler.rs
