Bit packing step 1

src/ContinuousIndexing.sol

@@ -2,19 +2,20 @@
 
 pragma solidity 0.8.23;
 
+import { UIntMath } from "./libs/UIntMath.sol";
+
 import { IContinuousIndexing } from "./interfaces/IContinuousIndexing.sol";
 
 import { ContinuousIndexingMath } from "./libs/ContinuousIndexingMath.sol";
 
 abstract contract ContinuousIndexing is IContinuousIndexing {
-    // TODO: Consider packing these into a single slot.
-    uint256 internal _latestIndex;
-    uint256 internal _latestRate;
-    uint256 internal _latestUpdateTimestamp;
+    uint192 internal _latestIndex;
+    uint24 internal _latestRate;
+    uint40 internal _latestUpdateTimestamp;
 
     constructor() {
-        _latestIndex = 1 * ContinuousIndexingMath.EXP_BASE_SCALE;
-        _latestUpdateTimestamp = block.timestamp;
+        _latestIndex = uint184(1 * ContinuousIndexingMath.EXP_BASE_SCALE);
+        _latestUpdateTimestamp = uint40(block.timestamp);
     }
 
     /******************************************************************************************************************\
@@ -30,9 +31,9 @@ abstract contract ContinuousIndexing is IContinuousIndexing {
 
         if (_latestUpdateTimestamp == block.timestamp && _latestRate == rate_) return currentIndex_;
 
-        _latestIndex = currentIndex_;
-        _latestRate = rate_;
-        _latestUpdateTimestamp = block.timestamp;
+        _latestIndex = UIntMath.safe192(currentIndex_);
+        _latestRate = UIntMath.safe24(rate_);
+        _latestUpdateTimestamp = uint40(block.timestamp);
 
         emit IndexUpdated(currentIndex_, _latestRate);
     }

src/interfaces/IProtocol.sol

@@ -299,7 +299,7 @@ interface IProtocol is IContinuousIndexing {
     /// @notice The mint proposal of minters, only 1 active proposal per minter
     function mintProposalOf(
         address minter
-    ) external view returns (uint256 mintId, address destination, uint256 amount, uint256 createdAt);
+    ) external view returns (uint256 mintId, uint256 createdAt, address destination, uint256 amount);
 
     /// @notice The minter's proposeRetrieval proposal amount
     function pendingCollateralRetrievalOf(

src/libs/UIntMath.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity 0.8.23;
+
+library UIntMath {
+    error InvalidUInt24();
+
+    error InvalidUInt40();
+
+    error InvalidUInt128();
+
+    error InvalidUInt192();
+
+    function safe24(uint256 n) internal pure returns (uint24) {
+        if (n > type(uint24).max) revert InvalidUInt24();
+        return uint24(n);
+    }
+
+    function safe40(uint256 n) internal pure returns (uint40) {
+        if (n > type(uint40).max) revert InvalidUInt40();
+        return uint40(n);
+    }
+
+    function safe128(uint256 n) internal pure returns (uint128) {
+        if (n > type(uint128).max) revert InvalidUInt128();
+        return uint128(n);
+    }
+
+    function safe192(uint256 n) internal pure returns (uint192) {
+        if (n > type(uint192).max) revert InvalidUInt192();
+        return uint192(n);
+    }
+}

test/Protocol.t.sol

@@ -292,7 +292,7 @@ contract ProtocolTests is Test {
 
         assertEq(mintId, expectedMintId);
 
-        (uint256 mintId_, address destination_, uint256 amount_, uint256 timestamp_) = _protocol.mintProposalOf(
+        (uint256 mintId_, uint256 timestamp_, address destination_, uint256 amount_) = _protocol.mintProposalOf(
             _minter1
         );
 
@@ -351,7 +351,7 @@ contract ProtocolTests is Test {
         _protocol.mintM(mintId);
 
         // check that mint request has been deleted
-        (uint256 mintId_, address destination_, uint256 amount_, uint256 timestamp_) = _protocol.mintProposalOf(
+        (uint256 mintId_, uint256 timestamp_, address destination_, uint256 amount_) = _protocol.mintProposalOf(
             _minter1
         );
 
@@ -519,7 +519,7 @@ contract ProtocolTests is Test {
         vm.prank(_validator1);
         _protocol.cancelMint(_minter1, mintId);
 
-        (uint256 mintId_, address destination_, uint256 amount_, uint256 timestamp) = _protocol.mintProposalOf(
+        (uint256 mintId_, uint256 timestamp, address destination_, uint256 amount_) = _protocol.mintProposalOf(
             _minter1
         );
 
@@ -536,7 +536,7 @@ contract ProtocolTests is Test {
         vm.prank(_alice);
         _protocol.cancelMint(_minter1, mintId);
 
-        (uint256 mintId_, address destination_, uint256 amount_, uint256 timestamp_) = _protocol.mintProposalOf(
+        (uint256 mintId_, uint256 timestamp_, address destination_, uint256 amount_) = _protocol.mintProposalOf(
             _minter1
         );
 

test/utils/MTokenHarness.sol

@@ -2,21 +2,23 @@
 
 pragma solidity 0.8.23;
 
+import { UIntMath } from "../../src/libs/UIntMath.sol";
+
 import { MToken } from "../../src/MToken.sol";
 
 contract MTokenHarness is MToken {
     constructor(address spogRegistrar_, address protocol_) MToken(spogRegistrar_, protocol_) {}
 
     function setLatestIndex(uint256 index_) external {
-        _latestIndex = index_;
+        _latestIndex = UIntMath.safe192(index_);
     }
 
     function setLatestRate(uint256 rate_) external {
-        _latestRate = rate_;
+        _latestRate = UIntMath.safe24(rate_);
     }
 
     function setLatestUpdated(uint256 timestamp_) external {
-        _latestUpdateTimestamp = timestamp_;
+        _latestUpdateTimestamp = uint40(timestamp_);
     }
 
     function setIsEarning(address account_, bool isEarning_) external {

test/utils/ProtocolHarness.sol

@@ -2,6 +2,8 @@
 
 pragma solidity 0.8.23;
 
+import { UIntMath } from "../../src/libs/UIntMath.sol";
+
 import { Protocol } from "../../src/Protocol.sol";
 
 contract ProtocolHarness is Protocol {
@@ -16,7 +18,7 @@ contract ProtocolHarness is Protocol {
     }
 
     function setActiveMinter(address minter_, bool isActive_) external {
-        _isActiveMinter[minter_] = isActive_;
+        _minterBasics[minter_].isActive = isActive_;
     }
 
     function setMintProposalOf(
@@ -26,39 +28,45 @@ contract ProtocolHarness is Protocol {
         address destination_
     ) external returns (uint256 mintId_) {
         mintId_ = ++_mintNonce;
-        _mintProposals[minter_] = MintProposal(mintId_, destination_, amount_, createdAt_);
+
+        _mintProposals[minter_] = MintProposal(
+            uint48(mintId_),
+            uint40(createdAt_),
+            destination_,
+            UIntMath.safe128(amount_)
+        );
     }
 
     function setCollateralOf(address minter_, uint256 collateral_) external {
-        _collaterals[minter_] = collateral_;
+        _minterBasics[minter_].collateral = UIntMath.safe128(collateral_);
     }
 
     function setCollateralUpdateOf(address minter_, uint256 lastUpdated_) external {
-        _lastCollateralUpdates[minter_] = lastUpdated_;
+        _minterBasics[minter_].updateTimestamp = uint40(lastUpdated_);
     }
 
     function setLastCollateralUpdateIntervalOf(address minter_, uint256 updateInterval_) external {
-        _lastUpdateIntervals[minter_] = updateInterval_;
+        _minterBasics[minter_].lastUpdateInterval = uint32(updateInterval_);
     }
 
     function setPenalizedUntilOf(address minter_, uint256 penalizedUntil_) external {
-        _penalizedUntilTimestamps[minter_] = penalizedUntil_;
+        _minterBasics[minter_].penalizedUntilTimestamp = uint40(penalizedUntil_);
     }
 
     function setPrincipalOfActiveOwedMOf(address minter_, uint256 amount_) external {
-        _principalOfActiveOwedM[minter_] = amount_;
-        _totalPrincipalOfActiveOwedM += amount_; // TODO: fix this side effect.
+        _owedM[minter_].principalOfActive = UIntMath.safe128(amount_);
+        _totalPrincipalOfActiveOwedM += UIntMath.safe128(amount_); // TODO: fix this side effect. ?
     }
 
     function setLatestIndex(uint256 index_) external {
-        _latestIndex = index_;
+        _latestIndex = UIntMath.safe192(index_);
     }
 
     function setLatestRate(uint256 rate_) external {
-        _latestRate = rate_;
+        _latestRate = UIntMath.safe24(rate_);
     }
 
     function principalOfActiveOwedMOf(address minter_) external view returns (uint256 principalOfActiveOwedM_) {
-        return _principalOfActiveOwedM[minter_];
+        return _owedM[minter_].principalOfActive;
     }
 }