Box all large values in state and messages.

Fix other lints.

Note: not everything needs to be boxed, but doing so for simplicity.
Smaller values should be used directly here.

Author: sapinb

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

@@ -99,7 +99,7 @@ fn stf(_config: &Config, state: State, input: Input) -> State {
                     by_deposit: prev_by_deposit,
                 }
             }
-            State::SendingAdaptorMsg | State::DepositReady { .. } => State::Consumed { by_deposit },
+            State::SendingAdaptorMsg | State::DepositReady => State::Consumed { by_deposit },
             _ => state,
         },
     }

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

@@ -44,8 +44,8 @@ pub enum State {
     WaitForAdaptors,
     DepositReady {
         adaptor_msg_id: MsgId,
-        deposit_adaptors: DepositAdaptors,
-        withdrawal_adaptors: WithdrawalAdaptors,
+        deposit_adaptors: Box<DepositAdaptors>,
+        withdrawal_adaptors: Box<WithdrawalAdaptors>,
     },
     Completed {
         counterproof_sig: (), // TODO: counterproof sig type
@@ -99,6 +99,7 @@ fn stf(_config: &Config, state: State, input: Input) -> State {
         },
         Input::GenerateCounterproofSignature(counterproof) => match state {
             State::DepositReady { .. } => {
+                #[expect(clippy::let_unit_value, reason = "TODO: correct type")]
                 let counterproof_sig = generate_counterproof_signature(counterproof);
                 State::Completed { counterproof_sig }
             }

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

@@ -46,48 +46,48 @@ pub enum State {
     // challenge sent, waiting for challenge response
     ReceivedCommitments {
         commit_msg_id: MsgId,
-        polynomial_commitments: PolynomialCommitments,
-        garbling_table_commitments: GarblingTableCommitments,
+        polynomial_commitments: Box<PolynomialCommitments>,
+        garbling_table_commitments: Box<GarblingTableCommitments>,
     },
     // got challenge ack, now waiting for challenge response
     WaitChallengeResponse {
-        polynomial_commitments: PolynomialCommitments,
-        garbling_table_commitments: GarblingTableCommitments,
+        polynomial_commitments: Box<PolynomialCommitments>,
+        garbling_table_commitments: Box<GarblingTableCommitments>,
     },
     // received challenge response
     // verified shares are correct
     // triggered garb table verification for opened tables
     // waiting for verification to complete
     ReceivedChallegeResponse {
         challenge_response_msg_id: MsgId,
-        polynomial_commitments: PolynomialCommitments,
-        garbling_table_commitments: GarblingTableCommitments,
-        opened_input_shares: OpenedInputShares,
-        opened_output_shares: OpenedOutputShares,
-        reserved_setup_input_shares: ReservedSetupInputShares,
-        opened_garbling_seeds: OpenedGarblingSeeds,
+        polynomial_commitments: Box<PolynomialCommitments>,
+        garbling_table_commitments: Box<GarblingTableCommitments>,
+        opened_input_shares: Box<OpenedInputShares>,
+        opened_output_shares: Box<OpenedOutputShares>,
+        reserved_setup_input_shares: Box<ReservedSetupInputShares>,
+        opened_garbling_seeds: Box<OpenedGarblingSeeds>,
     },
     // verified commitments are valid for opened tables
     // triggered receive and verify remaining tables
     // waiting for tables to be received
     VerifiedGarblingTableCommitments {
-        polynomial_commitments: PolynomialCommitments,
-        garbling_table_commitments: GarblingTableCommitments,
-        challenge_indices: ChallengeIndices,
-        opened_input_shares: OpenedInputShares,
-        opened_output_shares: OpenedOutputShares,
-        reserved_setup_input_shares: ReservedSetupInputShares,
-        opened_garbling_seeds: OpenedGarblingSeeds,
+        polynomial_commitments: Box<PolynomialCommitments>,
+        garbling_table_commitments: Box<GarblingTableCommitments>,
+        challenge_indices: Box<ChallengeIndices>,
+        opened_input_shares: Box<OpenedInputShares>,
+        opened_output_shares: Box<OpenedOutputShares>,
+        reserved_setup_input_shares: Box<ReservedSetupInputShares>,
+        opened_garbling_seeds: Box<OpenedGarblingSeeds>,
     },
     SetupComplete {
         // TODO: remove states that are not needed
-        polynomial_commitments: PolynomialCommitments,
-        garbling_table_commitments: GarblingTableCommitments,
-        challenge_indices: ChallengeIndices,
-        opened_input_shares: OpenedInputShares,
-        opened_output_shares: OpenedOutputShares,
-        reserved_setup_input_shares: ReservedSetupInputShares,
-        opened_garbling_seeds: OpenedGarblingSeeds,
+        polynomial_commitments: Box<PolynomialCommitments>,
+        garbling_table_commitments: Box<GarblingTableCommitments>,
+        challenge_indices: Box<ChallengeIndices>,
+        opened_input_shares: Box<OpenedInputShares>,
+        opened_output_shares: Box<OpenedOutputShares>,
+        reserved_setup_input_shares: Box<ReservedSetupInputShares>,
+        opened_garbling_seeds: Box<OpenedGarblingSeeds>,
     },
     SetupConsumed {
         by_deposit: StateMachinePairId,
@@ -115,7 +115,7 @@ pub enum Action {
     SendCommitAck(MsgId),
     SendChallengeMsg(ChallengeMsg),
     SendChallengeResponseAck(MsgId),
-    VerifyOpenedGarbTableCommitments(OpenedGarblingSeeds, GarblingTableCommitments),
+    VerifyOpenedGarbTableCommitments(Box<OpenedGarblingSeeds>, Box<GarblingTableCommitments>),
     ReceiveGarblingTables(()), // TODO: types
 }
 
@@ -183,7 +183,7 @@ fn stf(config: &Config, state: State, input: Input) -> State {
                 opened_garbling_seeds,
                 ..
             } => {
-                let challenge_indices = generate_challenge_indices(&config.seed);
+                let challenge_indices = Box::new(generate_challenge_indices(&config.seed));
                 State::VerifiedGarblingTableCommitments {
                     polynomial_commitments,
                     garbling_table_commitments,
@@ -227,7 +227,7 @@ fn emit_actions(config: &Config, state: &State) -> Vec<Action> {
     match state {
         State::Initialized => vec![],
         State::ReceivedCommitments { commit_msg_id, .. } => {
-            let challenge_indices = generate_challenge_indices(&config.seed);
+            let challenge_indices = Box::new(generate_challenge_indices(&config.seed));
             vec![
                 Action::SendCommitAck(*commit_msg_id),
                 Action::SendChallengeMsg(ChallengeMsg { challenge_indices }),
@@ -243,8 +243,8 @@ fn emit_actions(config: &Config, state: &State) -> Vec<Action> {
             vec![
                 Action::SendChallengeResponseAck(*challenge_response_msg_id),
                 Action::VerifyOpenedGarbTableCommitments(
-                    *opened_garbling_seeds,
-                    *garbling_table_commitments,
+                    opened_garbling_seeds.clone(),
+                    garbling_table_commitments.clone(),
                 ),
             ]
         }

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

@@ -40,19 +40,23 @@ pub enum State {
     ///
     /// Q: should polynomial commitments be stored or re-generated when needed ?
     SendCommit {
-        garbling_table_commitments: GarblingTableCommitments,
+        garbling_table_commitments: Box<GarblingTableCommitments>,
     },
     /// Wait for challenge msg
     WaitForChallenge,
     /// Got challenge message, send ack and challenge response
     ReceivedChallege {
         challenge_msg_id: MsgId,
-        challenge_idxs: ChallengeIndices,
+        challenge_idxs: Box<ChallengeIndices>,
     },
     /// Challenge response msg ack received, send garbling tables
-    TransferGarblingTables { challenge_idxs: ChallengeIndices },
+    TransferGarblingTables {
+        challenge_idxs: Box<ChallengeIndices>,
+    },
     /// Setup is completed, ready to be used for deposits.
-    SetupComplete { challenge_idxs: ChallengeIndices },
+    SetupComplete {
+        challenge_idxs: Box<ChallengeIndices>,
+    },
     /// Setup is consumed by a withdrawal dispute. Cannot be reused.
     SetupConsumed { by_deposit: StateMachinePairId },
     /// Setup was aborted due to a protocol violation.
@@ -71,7 +75,7 @@ pub struct Config {
 #[derive(Debug)]
 #[expect(missing_docs, reason = "wip")]
 pub enum Input {
-    GTCommitmentsGenerated(GarblingTableCommitments),
+    GTCommitmentsGenerated(Box<GarblingTableCommitments>),
     RecvCommitMessageAck,
     RecvChallengeMsg(ChallengeMsg),
     RecvChallengeReponseAck,
@@ -140,7 +144,7 @@ fn emit_actions(config: &Config, state: &State) -> Vec<Action> {
         State::SendCommit {
             garbling_table_commitments,
         } => {
-            let polynomial_commitments = generate_polynomial_commmitments(config.seed);
+            let polynomial_commitments = Box::new(generate_polynomial_commmitments(config.seed));
             let commit_msg = CommitMsg {
                 polynomial_commitments,
                 garbling_table_commitments: garbling_table_commitments.clone(),
@@ -154,7 +158,7 @@ fn emit_actions(config: &Config, state: &State) -> Vec<Action> {
         } => {
             let challenge_response = prepare_challenge_response_msg(config.seed, challenge_idxs);
             vec![
-                Action::SendChallengeMsgAck(challenge_msg_id.clone()),
+                Action::SendChallengeMsgAck(*challenge_msg_id),
                 Action::SendChallengeResponseMsg(challenge_response),
             ]
         }

crates/cac/types/src/msgs.rs

@@ -48,30 +48,30 @@ pub trait HasMsgId {
 #[derive(Clone, Debug)]
 pub struct CommitMsg {
     /// N_INPUT_WIRES * 256 + 1
-    pub polynomial_commitments: PolynomialCommitments,
+    pub polynomial_commitments: Box<PolynomialCommitments>,
     /// N_CIRCUITS
-    pub garbling_table_commitments: GarblingTableCommitments,
+    pub garbling_table_commitments: Box<GarblingTableCommitments>,
 }
 
 /// ChallengeMsg: Evaluator -> Garbler
 #[derive(Clone, Debug)]
 pub struct ChallengeMsg {
     /// N_COEFFICIENTS
-    pub challenge_indices: ChallengeIndices,
+    pub challenge_indices: Box<ChallengeIndices>,
 }
 
 /// ChallengeResponseMsg: Garbler -> Evaluator
 /// Note: Garbling Tables are sent separately
 #[derive(Clone, Debug)]
 pub struct ChallengeResponseMsg {
     /// N_COEFFICIENTS * N_INPUT_WIRES * 256
-    pub opened_input_shares: OpenedInputShares,
+    pub opened_input_shares: Box<OpenedInputShares>,
     /// N_SETUP_INPUT_WIRES * 256
-    pub reserved_setup_input_shares: ReservedSetupInputShares,
+    pub reserved_setup_input_shares: Box<ReservedSetupInputShares>,
     /// N_COEFFICIENTS
-    pub opened_output_shares: OpenedOutputShares,
+    pub opened_output_shares: Box<OpenedOutputShares>,
     /// N_COEFFICIENTS
-    pub opened_garbling_seeds: OpenedGarblingSeeds,
+    pub opened_garbling_seeds: Box<OpenedGarblingSeeds>,
 }
 
 /// N_DEPOSIT_INPUT_WIRES
@@ -83,9 +83,9 @@ pub type WithdrawalAdaptors = [[Adaptor; 256]; N_WITHDRAWAL_INPUT_WIRES];
 #[derive(Clone, Debug)]
 pub struct AdaptorMsg {
     /// N_DEPOSIT_INPUT_WIRES
-    pub deposit_adaptors: DepositAdaptors,
+    pub deposit_adaptors: Box<DepositAdaptors>,
     /// N_WITHDRAWAL_INPUT_WIRES * 256
-    pub withdrawal_adaptors: WithdrawalAdaptors,
+    pub withdrawal_adaptors: Box<WithdrawalAdaptors>,
 }
 
 impl HasMsgId for CommitMsg {

crates/network/api/src/lib.rs

@@ -5,14 +5,14 @@ use async_trait::async_trait;
 use futures::stream::BoxStream;
 use mosaic_common::{
     PeerId,
-    codec::{Decode, Encode},
+    codec::{Decodable, Encodable},
 };
 use thiserror::Error;
 
 /// Trait alias for network message bounds.
-pub trait NetworkMessage: Send + Clone + Encode + Decode + 'static {}
+pub trait NetworkMessage: Send + Clone + Encodable + Decodable + 'static {}
 
-impl<T> NetworkMessage for T where T: Send + Clone + Encode + Decode + 'static {}
+impl<T> NetworkMessage for T where T: Send + Clone + Encodable + Decodable + 'static {}
 
 /// A message to be sent to a specific peer.
 #[derive(Debug, Clone)]

crates/state-machine/api/Cargo.toml

@@ -14,7 +14,6 @@ keywords.workspace = true
 mosaic-cac-proto-types.workspace = true
 mosaic-cac-types.workspace = true
 mosaic-common.workspace = true
-mosaic-vs3.workspace = true
 
 [lints]
 workspace = true

crates/state-machine/api/src/types/id.rs

@@ -11,6 +11,7 @@ pub enum StateMachinePhase {
 
 /// Uniquely identifies a state machine pair run between 2 parties (type, garbler_peer,
 /// evaluator_peer, instance).
+///
 /// As a single mosaic instance only holds one side of the pair, this id also uniquely identifies a
 /// state machine inside one mosaic client.
 #[derive(Debug)]

crates/state-machine/api/src/types/msgs.rs

@@ -1,6 +1,6 @@
-use mosaic_cac_types::{GarblingTableCommitments, Msg, OpenedGarblingSeeds, Seed, SetupInputs};
-use mosaic_common::constants::N_EVAL_CIRCUITS;
-use mosaic_vs3::Index;
+use mosaic_cac_types::{
+    EvaluationIndices, GarblingTableCommitments, Msg, OpenedGarblingSeeds, Seed, SetupInputs,
+};
 
 use crate::{StateMachineMetadata, StateMachinePairId};
 
@@ -43,7 +43,7 @@ pub enum ExecutorInputMsgType {
 #[derive(Debug)]
 #[expect(missing_docs, reason = "wip")]
 pub enum JobCompletionReport {
-    GTCommitmentsGenerated(GarblingTableCommitments),
+    GTCommitmentsGenerated(Box<GarblingTableCommitments>),
     GarblingTablesTransferred,
     GarblingTablesReceived(bool),
     GTCommitmentsVerified(bool),
@@ -99,8 +99,8 @@ pub enum ExecutorOutputMsgType {
 #[expect(missing_docs, reason = "wip")]
 pub enum JobExecution {
     GenerateGTCommitments(Seed),
-    TransferGarblingTables(Seed, [Index; N_EVAL_CIRCUITS]),
-    ReceiveAndVerifyGarblingTables([Index; N_EVAL_CIRCUITS], GarblingTableCommitments),
-    VerifyGTCommitments(OpenedGarblingSeeds, GarblingTableCommitments),
+    TransferGarblingTables(Seed, Box<EvaluationIndices>),
+    ReceiveAndVerifyGarblingTables(Box<EvaluationIndices>, Box<GarblingTableCommitments>),
+    VerifyGTCommitments(Box<OpenedGarblingSeeds>, Box<GarblingTableCommitments>),
     EvaluateGarbTables(()),
 }

crates/state-machine/executor/src/adaptor/setup_evaluator.rs

@@ -19,6 +19,7 @@ pub struct AdaptorState {
     challenge_response_ack: Option<MsgId>,
 }
 
+#[expect(clippy::derivable_impls, reason = "keeping this explicit")]
 impl Default for AdaptorState {
     fn default() -> Self {
         Self {