feat: generate inversions of abi.encodePacked() for StakingMessages.unpack*()

contracts/staking/StakingMessages.sol

@@ -4,6 +4,8 @@
 // SPDX-License-Identifier: Ecosystem
 pragma solidity 0.8.25;
 
+import {Unpack} from "./Unpack.sol";
+
 library StakingMessages {
     // The information that uniquely identifies a subnet validation period.
     // The SHA-256 hash of the concatenation of these field is the validationID.
@@ -48,28 +50,19 @@ library StakingMessages {
      *                        | 148 bytes |
      *                        +-----------+
      *
-     * @param valiationInfo The information to pack into the message.
+     * @param validationInfo The information to pack into the message.
      * @return The validationID and the packed message.
      */
-    function packRegisterSubnetValidatorMessage(ValidationInfo memory valiationInfo)
+    function packRegisterSubnetValidatorMessage(ValidationInfo memory validationInfo)
         internal
         pure
         returns (bytes32, bytes memory)
     {
-        (bytes32 validationID, bytes memory serializedValidationInfo) =
-            packValidationInfo(valiationInfo);
-
-        bytes memory res = new bytes(148);
-        // Pack the message type
-        for (uint256 i; i < 4; ++i) {
-            res[i] = bytes1(uint8(SUBNET_VALIDATOR_REGISTRATION_MESSAGE_TYPE_ID >> (8 * (3 - i))));
-        }
-        // Pack the validation info
-        for (uint256 i; i < 144; ++i) {
-            res[i + 4] = serializedValidationInfo[i];
-        }
-
-        return (validationID, res);
+        (bytes32 validationID, bytes memory serialized) = packAndHashValidationInfo(validationInfo);
+        return (
+            validationID,
+            abi.encodePacked(SUBNET_VALIDATOR_REGISTRATION_MESSAGE_TYPE_ID, serialized)
+        );
     }
 
     /**
@@ -84,53 +77,26 @@ library StakingMessages {
         pure
         returns (ValidationInfo memory)
     {
-        require(input.length == 148, "StakingMessages: Invalid message length");
+        (
+            bytes4 typeID,
+            bytes32 subnetID,
+            bytes32 nodeID,
+            bytes8 weight,
+            bytes8 expiry,
+            bytes memory signature
+        ) = Unpack.unpack_4_32_32_8_8_Dyn_Destructive(input);
 
-        // Unpack the type ID
-        uint32 typeID;
-        for (uint256 i; i < 4; ++i) {
-            typeID |= uint32(uint8(input[i])) << uint32((8 * (3 - i)));
-        }
         require(
-            typeID == SUBNET_VALIDATOR_REGISTRATION_MESSAGE_TYPE_ID,
+            uint32(typeID) == SUBNET_VALIDATOR_REGISTRATION_MESSAGE_TYPE_ID,
             "StakingMessages: Invalid message type"
         );
-
-        // Unpack the subnet ID
-        bytes32 subnetID;
-        for (uint256 i; i < 32; ++i) {
-            subnetID |= bytes32(uint256(uint8(input[i + 4])) << (8 * (31 - i)));
-        }
-
-        // Unpack the node ID
-        bytes32 nodeID;
-        for (uint256 i; i < 32; ++i) {
-            nodeID |= bytes32(uint256(uint8(input[i + 36])) << (8 * (31 - i)));
-        }
-
-        // Unpack the weight
-        uint64 weight;
-        for (uint256 i; i < 8; ++i) {
-            weight |= uint64(uint8(input[i + 68])) << uint64((8 * (7 - i)));
-        }
-
-        // Unpack the expiry
-        uint64 expiry;
-        for (uint256 i; i < 8; ++i) {
-            expiry |= uint64(uint8(input[i + 76])) << uint64((8 * (7 - i)));
-        }
-
-        // Unpack the signature
-        bytes memory signature = new bytes(64);
-        for (uint256 i; i < 64; ++i) {
-            signature[i] = input[i + 84];
-        }
+        require(signature.length == 64, "StakingMessages: Invalid unpacked signature length");
 
         return ValidationInfo({
             subnetID: subnetID,
             nodeID: nodeID,
-            weight: weight,
-            registrationExpiry: expiry,
+            weight: uint64(weight),
+            registrationExpiry: uint64(expiry),
             signature: signature
         });
     }
@@ -157,18 +123,7 @@ library StakingMessages {
         bytes32 validationID,
         bool valid
     ) internal pure returns (bytes memory) {
-        bytes memory res = new bytes(37);
-        // Pack the type ID.
-        for (uint256 i; i < 4; ++i) {
-            res[i] = bytes1(uint8(SUBNET_VALIDATOR_REGISTRATION_MESSAGE_TYPE_ID >> (8 * (3 - i))));
-        }
-        // Pack the validation ID.
-        for (uint256 i; i < 32; ++i) {
-            res[i + 4] = bytes1(uint8(uint256(validationID >> (8 * (31 - i)))));
-        }
-        // Pack the validity.
-        res[36] = bytes1(valid ? 1 : 0);
-        return res;
+        return abi.encodePacked(SUBNET_VALIDATOR_REGISTRATION_MESSAGE_TYPE_ID, validationID, valid);
     }
 
     /**
@@ -184,28 +139,12 @@ library StakingMessages {
         pure
         returns (bytes32, bool)
     {
-        require(input.length == 37, "StakingMessages: Invalid message length");
-
-        // Unpack the type ID
-        uint32 typeID;
-        for (uint256 i; i < 4; ++i) {
-            typeID |= uint32(uint8(input[i])) << uint32((8 * (3 - i)));
-        }
+        (bytes4 typeID, bytes32 validationID, bytes1 valid) = Unpack.unpack_4_32_1(input);
         require(
-            typeID == SUBNET_VALIDATOR_REGISTRATION_MESSAGE_TYPE_ID,
+            uint32(typeID) == SUBNET_VALIDATOR_REGISTRATION_MESSAGE_TYPE_ID,
             "StakingMessages: Invalid message type"
         );
-
-        // Unpack the validation ID.
-        bytes32 validationID;
-        for (uint256 i; i < 32; ++i) {
-            validationID |= bytes32(uint256(uint8(input[i + 4])) << (8 * (31 - i)));
-        }
-
-        // Unpack the validity
-        bool valid = input[36] != 0;
-
-        return (validationID, valid);
+        return (validationID, uint8(valid) != 0);
     }
 
     /**
@@ -233,24 +172,9 @@ library StakingMessages {
         uint64 nonce,
         uint64 weight
     ) internal pure returns (bytes memory) {
-        bytes memory res = new bytes(52);
-        // Pack the type ID.
-        for (uint256 i; i < 4; ++i) {
-            res[i] = bytes1(uint8(SET_SUBNET_VALIDATOR_WEIGHT_MESSAGE_TYPE_ID >> (8 * (3 - i))));
-        }
-        // Pack the validation ID.
-        for (uint256 i; i < 32; ++i) {
-            res[i + 4] = bytes1(uint8(uint256(validationID >> (8 * (31 - i)))));
-        }
-        // Pack the nonce.
-        for (uint256 i; i < 8; ++i) {
-            res[i + 36] = bytes1(uint8(nonce >> (8 * (7 - i))));
-        }
-        // Pack the weight.
-        for (uint256 i; i < 8; ++i) {
-            res[i + 44] = bytes1(uint8(weight >> (8 * (7 - i))));
-        }
-        return res;
+        return abi.encodePacked(
+            SET_SUBNET_VALIDATOR_WEIGHT_MESSAGE_TYPE_ID, validationID, nonce, weight
+        );
     }
 
     /**
@@ -265,37 +189,13 @@ library StakingMessages {
         pure
         returns (bytes32, uint64, uint64)
     {
-        require(input.length == 52, "StakingMessages: Invalid message length");
-
-        // Unpack the type ID.
-        uint32 typeID;
-        for (uint256 i; i < 4; ++i) {
-            typeID |= uint32(uint8(input[i])) << uint32((8 * (3 - i)));
-        }
+        (bytes4 typeID, bytes32 validationID, bytes8 nonce, bytes8 weight) =
+            Unpack.unpack_4_32_8_8(input);
         require(
-            typeID == SET_SUBNET_VALIDATOR_WEIGHT_MESSAGE_TYPE_ID,
+            uint32(typeID) == SET_SUBNET_VALIDATOR_WEIGHT_MESSAGE_TYPE_ID,
             "StakingMessages: Invalid message type"
         );
-
-        // Unpack the validation ID.
-        bytes32 validationID;
-        for (uint256 i; i < 32; ++i) {
-            validationID |= bytes32(uint256(uint8(input[i + 4])) << (8 * (31 - i)));
-        }
-
-        // Unpack the nonce.
-        uint64 nonce;
-        for (uint256 i; i < 8; ++i) {
-            nonce |= uint64(uint8(input[i + 36])) << uint64((8 * (7 - i)));
-        }
-
-        // Unpack the weight.
-        uint64 weight;
-        for (uint256 i; i < 8; ++i) {
-            weight |= uint64(uint8(input[i + 44])) << uint64((8 * (7 - i)));
-        }
-
-        return (validationID, nonce, weight);
+        return (validationID, uint64(nonce), uint64(weight));
     }
 
     /**
@@ -319,20 +219,7 @@ library StakingMessages {
         bytes32 validationID,
         uint64 uptime
     ) internal pure returns (bytes memory) {
-        bytes memory res = new bytes(44);
-        // Pack the type ID.
-        for (uint256 i; i < 4; ++i) {
-            res[i] = bytes1(uint8(VALIDATION_UPTIME_MESSAGE_TYPE_ID >> (8 * (3 - i))));
-        }
-        // Pack the validation ID.
-        for (uint256 i; i < 32; ++i) {
-            res[i + 4] = bytes1(uint8(uint256(validationID >> (8 * (31 - i)))));
-        }
-        // Pack the uptime.
-        for (uint256 i; i < 8; ++i) {
-            res[i + 36] = bytes1(uint8(uptime >> (8 * (7 - i))));
-        }
-        return res;
+        return abi.encodePacked(VALIDATION_UPTIME_MESSAGE_TYPE_ID, validationID, uptime);
     }
 
     /**
@@ -347,30 +234,12 @@ library StakingMessages {
         pure
         returns (bytes32, uint64)
     {
-        require(input.length == 44, "StakingMessages: Invalid message length");
-
-        // Unpack the type ID.
-        uint32 typeID;
-        for (uint256 i; i < 4; ++i) {
-            typeID |= uint32(uint8(input[i])) << uint32((8 * (3 - i)));
-        }
+        (bytes4 typeID, bytes32 validationID, bytes8 uptime) = Unpack.unpack_4_32_8(input);
         require(
-            typeID == VALIDATION_UPTIME_MESSAGE_TYPE_ID, "StakingMessages: Invalid message type"
+            uint32(typeID) == VALIDATION_UPTIME_MESSAGE_TYPE_ID,
+            "StakingMessages: Invalid message type"
         );
-
-        // Unpack the validation ID.
-        bytes32 validationID;
-        for (uint256 i; i < 32; ++i) {
-            validationID |= bytes32(uint256(uint8(input[i + 4])) << (8 * (31 - i)));
-        }
-
-        // Unpack the uptime.
-        uint64 uptime;
-        for (uint256 i; i < 8; ++i) {
-            uptime |= uint64(uint8(input[i + 36])) << uint64((8 * (7 - i)));
-        }
-
-        return (validationID, uptime);
+        return (validationID, uint64(uptime));
     }
 
     /**
@@ -391,36 +260,23 @@ library StakingMessages {
      *                        | 144 bytes |
      *                        +-----------+
      *
-     * @param validationInfo The information to pack.
+     * @param info The information to pack.
      * @return The validationID and the packed data.
      */
-    function packValidationInfo(ValidationInfo memory validationInfo)
+    function packValidationInfo(ValidationInfo memory info) internal pure returns (bytes memory) {
+        require(info.signature.length == 64, "StakingMessages: Invalid signature length");
+        return abi.encodePacked(
+            info.subnetID, info.nodeID, info.weight, info.registrationExpiry, info.signature
+        );
+    }
+
+    /// @dev Equivalent to returning `packValidationInfo(info)` and the SHA256 hash thereof.
+    function packAndHashValidationInfo(ValidationInfo memory info)
         internal
         pure
         returns (bytes32, bytes memory)
     {
-        require(validationInfo.signature.length == 64, "StakingMessages: Invalid signature length");
-        bytes memory res = new bytes(144);
-        // Pack the subnetID
-        for (uint256 i; i < 32; ++i) {
-            res[i] = validationInfo.subnetID[i];
-        }
-        // Pack the nodeID
-        for (uint256 i; i < 32; ++i) {
-            res[i + 32] = validationInfo.nodeID[i];
-        }
-        // Pack the weight
-        for (uint256 i; i < 8; ++i) {
-            res[i + 64] = bytes1(uint8(validationInfo.weight >> uint8((8 * (7 - i)))));
-        }
-        // Pack the registration expiry
-        for (uint256 i; i < 8; ++i) {
-            res[i + 72] = bytes1(uint8(validationInfo.registrationExpiry >> uint64((8 * (7 - i)))));
-        }
-        // Pack the signature
-        for (uint256 i; i < 64; ++i) {
-            res[i + 80] = validationInfo.signature[i];
-        }
+        bytes memory res = packValidationInfo(info);
         return (sha256(res), res);
     }
 
@@ -436,43 +292,15 @@ library StakingMessages {
         pure
         returns (ValidationInfo memory)
     {
-        require(input.length == 144, "StakingMessages: Invalid message length");
-
-        // Unpack the subnetID
-        bytes32 subnetID;
-        for (uint256 i; i < 32; ++i) {
-            subnetID |= bytes32(uint256(uint8(input[i])) << (8 * (31 - i)));
-        }
-
-        // Unpack the nodeID
-        bytes32 nodeID;
-        for (uint256 i; i < 32; ++i) {
-            nodeID |= bytes32(uint256(uint8(input[i + 32])) << (8 * (31 - i)));
-        }
-
-        // Unpack the weight
-        uint64 weight;
-        for (uint256 i; i < 8; ++i) {
-            weight |= uint64(uint8(input[i + 64])) << uint64((8 * (7 - i)));
-        }
-
-        // Unpack the registration expiry
-        uint64 expiry;
-        for (uint256 i; i < 8; ++i) {
-            expiry |= uint64(uint8(input[i + 72])) << uint64((8 * (7 - i)));
-        }
-
-        // Unpack the signature
-        bytes memory signature = new bytes(64);
-        for (uint256 i; i < 64; ++i) {
-            signature[i] = input[i + 80];
-        }
+        (bytes32 subnetID, bytes32 nodeID, bytes8 weight, bytes8 expiry, bytes memory signature) =
+            Unpack.unpack_32_32_8_8_Dyn_Destructive(input);
+        require(signature.length == 64, "StakingMessages: Invalid unpacked signature length");
 
         return ValidationInfo({
             subnetID: subnetID,
             nodeID: nodeID,
-            weight: weight,
-            registrationExpiry: expiry,
+            weight: uint64(weight),
+            registrationExpiry: uint64(expiry),
             signature: signature
         });
     }