Add doubles support for SignedCommitManager + optimize SLOADs

- getCommitAuthForDualSigned: drop startTimestamp check to eliminate 2
  SLOADs (storageKey lookup + config read). winnerIndex != 2 already
  catches never-started battles. Return gameMode for free from same slot.

- Engine.executeWithMovesForDoubles: new function that sets all 4 slot
  moves (p0Move, p0Move2, p1Move, p1Move2) and executes in one call.

- SignedCommitLib.DualSignedRevealDoubles: new EIP-712 struct covering
  2 move indices + 2 extra data fields per revealer for doubles.

- SignedCommitManager.executeWithDualSignedMovesForDoubles: doubles
  variant of the dual-signed flow. Committer hash uses revealMovePair
  preimage format. Validates gameMode to prevent singles/doubles mismatch.

https://claude.ai/code/session_01MdUWjZNL2QrK4utE8Lma7H

Author: claude

src/Engine.sol

@@ -366,6 +366,49 @@ contract Engine is IEngine, MappingAllocator {
         _executeInternal(battleKey, storageKey);
     }
 
+    /// @notice Sets all 4 slot moves for doubles and executes in a single call
+    /// @dev Like executeWithMoves but for doubles battles — sets p0Move, p0Move2, p1Move, p1Move2.
+    ///      Salt is per-player (not per-slot), matching the revealMovePair convention.
+    function executeWithMovesForDoubles(
+        bytes32 battleKey,
+        uint8 p0MoveIndex0,
+        uint240 p0ExtraData0,
+        uint8 p0MoveIndex1,
+        uint240 p0ExtraData1,
+        bytes32 p0Salt,
+        uint8 p1MoveIndex0,
+        uint240 p1ExtraData0,
+        uint8 p1MoveIndex1,
+        uint240 p1ExtraData1,
+        bytes32 p1Salt
+    ) external {
+        // Cache storage key
+        bytes32 storageKey = _getStorageKey(battleKey);
+        storageKeyForWrite = storageKey;
+
+        BattleConfig storage config = battleConfig[storageKey];
+
+        // Only moveManager can call this
+        if (msg.sender != config.moveManager) {
+            revert WrongCaller();
+        }
+
+        // Set p0 slot 0 + slot 1 moves
+        config.p0Move = _packMoveDecision(p0MoveIndex0, p0ExtraData0);
+        config.p0Move2 = _packMoveDecision(p0MoveIndex1, p0ExtraData1);
+        config.p0Salt = p0Salt;
+        emit P0MoveSet(battleKey, uint256(p0MoveIndex0) | (uint256(p0ExtraData0) << 8));
+
+        // Set p1 slot 0 + slot 1 moves
+        config.p1Move = _packMoveDecision(p1MoveIndex0, p1ExtraData0);
+        config.p1Move2 = _packMoveDecision(p1MoveIndex1, p1ExtraData1);
+        config.p1Salt = p1Salt;
+        emit P1MoveSet(battleKey, uint256(p1MoveIndex0) | (uint256(p1ExtraData0) << 8));
+
+        // Execute (skip MovesNotSet check since we just set them)
+        _executeInternal(battleKey, storageKey);
+    }
+
     /// @notice Internal execution logic shared by execute() and executeWithMoves()
     function _executeInternal(bytes32 battleKey, bytes32 storageKey) internal {
         // Load storage vars
@@ -2367,20 +2410,25 @@ contract Engine is IEngine, MappingAllocator {
     }
 
     /// @notice Lightweight getter for dual-signed flow that validates state and returns only needed fields
-    /// @dev Reverts internally if battle not started, already complete, or not a two-player turn
+    /// @dev Reverts if battle already complete or not a two-player turn.
+    ///      Skips startTimestamp check (saves 2 SLOADs): if battle was never started,
+    ///      winnerIndex defaults to 0 (not 2), so the GameAlreadyOver check catches it.
+    ///      Returns gameMode for free since slotSwitchFlagsAndGameMode is in the same
+    ///      storage slot as winnerIndex/playerSwitchForTurnFlag.
     function getCommitAuthForDualSigned(bytes32 battleKey)
         external
         view
-        returns (address committer, address revealer, uint64 turnId)
+        returns (address committer, address revealer, uint64 turnId, GameMode gameMode)
     {
-        bytes32 storageKey = _getStorageKey(battleKey);
         BattleData storage data = battleData[battleKey];
-        BattleConfig storage config = battleConfig[storageKey];
 
-        if (config.startTimestamp == 0) revert BattleNotStarted();
+        // winnerIndex == 0 for never-started battles (all zeros), != 2 catches both cases
         if (data.winnerIndex != 2) revert GameAlreadyOver();
         if (data.playerSwitchForTurnFlag != 2) revert NotTwoPlayerTurn();
 
+        // gameMode is free: slotSwitchFlagsAndGameMode is in the same slot as winnerIndex
+        gameMode = (data.slotSwitchFlagsAndGameMode & GAME_MODE_BIT) != 0 ? GameMode.Doubles : GameMode.Singles;
+
         turnId = data.turnId;
         if (turnId % 2 == 0) {
             committer = data.p0;

src/IEngine.sol

@@ -36,6 +36,19 @@ interface IEngine {
         bytes32 p1Salt,
         uint240 p1ExtraData
     ) external;
+    function executeWithMovesForDoubles(
+        bytes32 battleKey,
+        uint8 p0MoveIndex0,
+        uint240 p0ExtraData0,
+        uint8 p0MoveIndex1,
+        uint240 p0ExtraData1,
+        bytes32 p0Salt,
+        uint8 p1MoveIndex0,
+        uint240 p1ExtraData0,
+        uint8 p1MoveIndex1,
+        uint240 p1ExtraData1,
+        bytes32 p1Salt
+    ) external;
     function emitEngineEvent(bytes32 eventType, bytes memory extraData) external;
     function setUpstreamCaller(address caller) external;
 
@@ -96,7 +109,7 @@ interface IEngine {
     function getCommitAuthForDualSigned(bytes32 battleKey)
         external
         view
-        returns (address committer, address revealer, uint64 turnId);
+        returns (address committer, address revealer, uint64 turnId, GameMode gameMode);
     function getDamageCalcContext(bytes32 battleKey, uint256 attackerPlayerIndex, uint256 defenderPlayerIndex)
         external
         view

src/commit-manager/SignedCommitLib.sol

@@ -69,4 +69,40 @@ library SignedCommitLib {
             )
         );
     }
+
+    /// @notice Struct for the dual-signed reveal flow in doubles battles
+    /// @dev Like DualSignedReveal but covers 2 slot moves per player.
+    ///      The committer's hash covers both their slot moves (matching revealMovePair preimage).
+    ///      The revealer signs over both their slot moves + the committer's hash.
+    struct DualSignedRevealDoubles {
+        bytes32 battleKey;
+        uint64 turnId;
+        bytes32 committerMoveHash; // hash(moveIndex0, moveIndex1, salt, extraData0, extraData1)
+        uint8 revealerMoveIndex0; // Slot 0 move
+        uint8 revealerMoveIndex1; // Slot 1 move
+        bytes32 revealerSalt;
+        uint240 revealerExtraData0; // Slot 0 extra data
+        uint240 revealerExtraData1; // Slot 1 extra data
+    }
+
+    /// @notice Hashes a DualSignedRevealDoubles struct according to EIP-712
+    /// @param reveal The DualSignedRevealDoubles struct to hash
+    /// @return The EIP-712 struct hash
+    function hashDualSignedRevealDoubles(DualSignedRevealDoubles memory reveal) internal pure returns (bytes32) {
+        return keccak256(
+            abi.encode(
+                keccak256(
+                    "DualSignedRevealDoubles(bytes32 battleKey,uint64 turnId,bytes32 committerMoveHash,uint8 revealerMoveIndex0,uint8 revealerMoveIndex1,bytes32 revealerSalt,uint240 revealerExtraData0,uint240 revealerExtraData1)"
+                ),
+                reveal.battleKey,
+                reveal.turnId,
+                reveal.committerMoveHash,
+                reveal.revealerMoveIndex0,
+                reveal.revealerMoveIndex1,
+                reveal.revealerSalt,
+                reveal.revealerExtraData0,
+                reveal.revealerExtraData1
+            )
+        );
+    }
 }

src/commit-manager/SignedCommitManager.sol

@@ -7,6 +7,7 @@ import {ECDSA} from "../lib/ECDSA.sol";
 import {SignedCommitLib} from "./SignedCommitLib.sol";
 import {IEngine} from "../IEngine.sol";
 import {CommitContext, PlayerDecisionData} from "../Structs.sol";
+import {GameMode} from "../Enums.sol";
 
 /// @title SignedCommitManager
 /// @notice Extends DefaultCommitManager with optimistic dual-signed commit flow
@@ -41,6 +42,9 @@ contract SignedCommitManager is DefaultCommitManager, EIP712 {
     /// @notice Thrown when trying to use dual-signed flow on a single-player turn
     error NotTwoPlayerTurn();
 
+    /// @notice Thrown when using singles function for a doubles battle or vice versa
+    error WrongGameMode();
+
     constructor(IEngine engine) DefaultCommitManager(engine) {}
 
     /// @inheritdoc EIP712
@@ -54,7 +58,7 @@ contract SignedCommitManager is DefaultCommitManager, EIP712 {
         version = "1";
     }
 
-    /// @notice Executes a turn using dual-signed moves from both players (gas-optimized)
+    /// @notice Executes a turn using dual-signed moves from both players (singles only)
     /// @dev The committer (A) submits both moves. The revealer (B) has signed over
     ///      their move and A's move hash, binding both players to their moves.
     /// @param battleKey The battle identifier
@@ -77,9 +81,11 @@ contract SignedCommitManager is DefaultCommitManager, EIP712 {
         bytes memory revealerSignature
     ) external {
         // Use lightweight getter (validates internally, reverts on bad state)
-        (address committer, address revealer, uint64 turnId) =
+        (address committer, address revealer, uint64 turnId, GameMode gameMode) =
             ENGINE.getCommitAuthForDualSigned(battleKey);
 
+        if (gameMode != GameMode.Singles) revert WrongGameMode();
+
         // Caller must be the committing player
         if (msg.sender != committer) {
             revert CallerNotCommitter();
@@ -123,10 +129,102 @@ contract SignedCommitManager is DefaultCommitManager, EIP712 {
         }
     }
 
+    /// @notice Executes a turn using dual-signed moves for doubles battles
+    /// @dev Same security model as executeWithDualSignedMoves but each player has 2 slot moves.
+    ///      The committer's hash covers both slot moves: keccak256(moveIndex0, moveIndex1, salt, extraData0, extraData1)
+    ///      matching the revealMovePair preimage format.
+    /// @param battleKey The battle identifier
+    /// @param committerMoveIndex0 The committer's slot 0 move index
+    /// @param committerExtraData0 The committer's slot 0 extra data
+    /// @param committerMoveIndex1 The committer's slot 1 move index
+    /// @param committerExtraData1 The committer's slot 1 extra data
+    /// @param committerSalt The committer's salt (shared across both slots)
+    /// @param revealerMoveIndex0 The revealer's slot 0 move index
+    /// @param revealerExtraData0 The revealer's slot 0 extra data
+    /// @param revealerMoveIndex1 The revealer's slot 1 move index
+    /// @param revealerExtraData1 The revealer's slot 1 extra data
+    /// @param revealerSalt The revealer's salt (shared across both slots)
+    /// @param revealerSignature EIP-712 signature from the revealer over DualSignedRevealDoubles
+    function executeWithDualSignedMovesForDoubles(
+        bytes32 battleKey,
+        uint8 committerMoveIndex0,
+        uint240 committerExtraData0,
+        uint8 committerMoveIndex1,
+        uint240 committerExtraData1,
+        bytes32 committerSalt,
+        uint8 revealerMoveIndex0,
+        uint240 revealerExtraData0,
+        uint8 revealerMoveIndex1,
+        uint240 revealerExtraData1,
+        bytes32 revealerSalt,
+        bytes memory revealerSignature
+    ) external {
+        // Use lightweight getter (validates internally, reverts on bad state)
+        (address committer, address revealer, uint64 turnId, GameMode gameMode) =
+            ENGINE.getCommitAuthForDualSigned(battleKey);
+
+        if (gameMode != GameMode.Doubles) revert WrongGameMode();
+
+        // Caller must be the committing player
+        if (msg.sender != committer) {
+            revert CallerNotCommitter();
+        }
+
+        // Compute the committer's move hash (matches revealMovePair preimage format)
+        bytes32 committerMoveHash = keccak256(
+            abi.encodePacked(
+                committerMoveIndex0, committerMoveIndex1, committerSalt, committerExtraData0, committerExtraData1
+            )
+        );
+
+        // Verify the revealer's signature over DualSignedRevealDoubles
+        SignedCommitLib.DualSignedRevealDoubles memory reveal = SignedCommitLib.DualSignedRevealDoubles({
+            battleKey: battleKey,
+            turnId: turnId,
+            committerMoveHash: committerMoveHash,
+            revealerMoveIndex0: revealerMoveIndex0,
+            revealerMoveIndex1: revealerMoveIndex1,
+            revealerSalt: revealerSalt,
+            revealerExtraData0: revealerExtraData0,
+            revealerExtraData1: revealerExtraData1
+        });
+
+        bytes32 digest = _hashTypedData(SignedCommitLib.hashDualSignedRevealDoubles(reveal));
+        if (ECDSA.recover(digest, revealerSignature) != revealer) {
+            revert InvalidSignature();
+        }
+
+        // Execute with all 4 slot moves in a single call
+        if (turnId % 2 == 0) {
+            // Committer is p0
+            ENGINE.executeWithMovesForDoubles(
+                battleKey,
+                committerMoveIndex0, committerExtraData0,
+                committerMoveIndex1, committerExtraData1,
+                committerSalt,
+                revealerMoveIndex0, revealerExtraData0,
+                revealerMoveIndex1, revealerExtraData1,
+                revealerSalt
+            );
+        } else {
+            // Committer is p1
+            ENGINE.executeWithMovesForDoubles(
+                battleKey,
+                revealerMoveIndex0, revealerExtraData0,
+                revealerMoveIndex1, revealerExtraData1,
+                revealerSalt,
+                committerMoveIndex0, committerExtraData0,
+                committerMoveIndex1, committerExtraData1,
+                committerSalt
+            );
+        }
+    }
+
     /// @notice Allows anyone to publish the committer's signed commitment on-chain
     /// @dev This is a fallback mechanism if the committer (A) doesn't submit via
     ///      executeWithDualSignedMoves. The revealer (B) can use this to force A's
     ///      commitment on-chain, then proceed with the normal reveal flow.
+    ///      Works for both singles and doubles - the moveHash is format-agnostic.
     /// @param battleKey The battle identifier
     /// @param moveHash The committer's move hash
     /// @param committerSignature EIP-712 signature from the committer over