Staking manager unit tests

contracts/staking/NativeTokenStakingManager.sol

@@ -8,9 +8,15 @@ pragma solidity 0.8.25;
 import {INativeTokenStakingManager} from "./interfaces/INativeTokenStakingManager.sol";
 import {Address} from "@openzeppelin/[email protected]/utils/Address.sol";
 import {StakingManager} from "./StakingManager.sol";
+import {StakingManagerSettings} from "./interfaces/IStakingManager.sol";
 
 contract NativeTokenStakingManager is StakingManager, INativeTokenStakingManager {
     using Address for address payable;
+
+    constructor(StakingManagerSettings memory settings) {
+        StakingManager.initialize(settings);
+    }
+
     /**
      * @notice Begins the validator registration process. Locks the provided native asset in the contract as the stake.
      * @param nodeID The node ID of the validator being registered.
@@ -22,7 +28,6 @@ contract NativeTokenStakingManager is StakingManager, INativeTokenStakingManager
      * The signature field will be validated by the P-Chain. Implementations may choose to validate that the signature
      * field is well-formed but it is not required.
      */
-
     function initializeValidatorRegistration(
         bytes32 nodeID,
         uint64 registrationExpiry,

contracts/staking/StakingManager.sol

@@ -5,7 +5,7 @@
 
 pragma solidity 0.8.25;
 
-import {IStakingManager} from "./interfaces/IStakingManager.sol";
+import {IStakingManager, StakingManagerSettings} from "./interfaces/IStakingManager.sol";
 import {
     WarpMessage,
     IWarpMessenger
@@ -78,62 +78,50 @@
         }
     }
 
-    struct InitialStakerInfo {
-        StakingMessages.ValidationInfo validationInfo;
-        address owner;
-    }
-
-    struct StakingManagerSettings {
-        bytes32 pChainBlockchainID;
-        bytes32 subnetID;
-        uint256 minimumStakeAmount;
-        uint256 maximumStakeAmount;
-        uint64 minimumStakeDuration;
-        uint8 maximumHourlyChurn;
-        InitialStakerInfo[] initialStakers;
-        IRewardCalculator rewardCalculator;
-    }
-
-    function initialize(StakingManagerSettings calldata settings) public {
+    function initialize(StakingManagerSettings memory settings) public {
         StakingManagerStorage storage $ = _getStakingManagerStorage();
         $._warpMessenger = IWarpMessenger(0x0200000000000000000000000000000000000005);
         $._pChainBlockchainID = settings.pChainBlockchainID;
         $._subnetID = settings.subnetID;
         $._minimumStakeAmount = settings.minimumStakeAmount;
         $._maximumStakeAmount = settings.maximumStakeAmount;
         $._minimumStakeDuration = settings.minimumStakeDuration;
         $._maximumHourlyChurn = settings.maximumHourlyChurn;
         // Add each of the initial stakers as validators
         uint64 initialStake;
         for (uint256 i; i < settings.initialStakers.length; ++i) {
             (bytes32 validationID,) =
                 StakingMessages.packValidationInfo(settings.initialStakers[i].validationInfo);
             $._validationPeriods[validationID] = Validator({
                 status: ValidatorStatus.Active,
                 nodeID: settings.initialStakers[i].validationInfo.nodeID,
                 weight: settings.initialStakers[i].validationInfo.weight,
                 startedAt: uint64(block.timestamp),
                 endedAt: 0,
                 uptimeSeconds: 0,
                 owner: settings.initialStakers[i].owner,
                 rewarded: false,
                 messageNonce: 0
             });
             initialStake += settings.initialStakers[i].validationInfo.weight;
         }
         $._remainingInitialStake = initialStake;
         $._rewardCalculator = settings.rewardCalculator;
     }
 
     /**
      * @notice Modifier to ensure that the initial stake has been provided.
      */
     modifier onlyWhenInitialStakeProvided() {
-        StakingManagerStorage storage $ = _getStakingManagerStorage();
-        require($._remainingInitialStake > 0, "StakingManager: Initial stake not provided");
+        require(initialStakeProvided(), "StakingManager: Initial stake not provided");
         _;
     }
 
+    function initialStakeProvided() public view returns (bool) {
+        StakingManagerStorage storage $ = _getStakingManagerStorage();
+        return $._remainingInitialStake == 0;
+    }
+
     /**
      * @notice Called to provide initial stake amount for original validators added prior to the contract's initialization.
      */
@@ -425,6 +413,7 @@
         // Calculate the reward for the validator.
 
         // Emit event.
+        emit ValidationPeriodEnded(validationID);
     }
 
     /**
@@ -434,6 +423,10 @@
      */
     function _checkAndUpdateChurnTracker(uint64 amount) private {
         StakingManagerStorage storage $ = _getStakingManagerStorage();
+        if ($._maximumHourlyChurn == 0) {
+            return;
+        }
+
         ValidatorChurnPeriod storage churnTracker = $._churnTracker;
         uint256 currentTime = block.timestamp;
         if (currentTime - churnTracker.startedAt >= 1 hours) {

contracts/staking/StakingMessages.sol

@@ -47,6 +47,9 @@ library StakingMessages {
      * +-----------+----------+-----------+
      *                        | 148 bytes |
      *                        +-----------+
+     *
+     * @param valiationInfo The information to pack into the message.
+     * @return The validationID and the packed message.
      */
     function packRegisterSubnetValidatorMessage(ValidationInfo memory valiationInfo)
         internal
@@ -70,7 +73,70 @@ library StakingMessages {
     }
 
     /**
-     * @notice Unpacks a byte array as a RegisterSubnetValidator message.
+     * @notice Unpacks a byte array as a RegisterSubnetValidatorMessage message.
+     * The message format specification is the same as the one used in above for packing.
+     *
+     * @param input The byte array to unpack.
+     * @return the unpacked ValidationInfo.
+     */
+    function unpackRegisterSubnetValidatorMessage(bytes memory input)
+        internal
+        pure
+        returns (ValidationInfo memory)
+    {
+        require(input.length == 148, "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)));
+        }
+        require(
+            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];
+        }
+
+        return ValidationInfo({
+            subnetID: subnetID,
+            nodeID: nodeID,
+            weight: weight,
+            registrationExpiry: expiry,
+            signature: signature
+        });
+    }
+
+    /**
+     * @notice Packs a SubnetValidatorRegistrationMessage into a byte array.
      * The message format specification is:
      * +--------------+----------+----------+
      * |       typeID :   uint32 |  4 bytes |
@@ -81,6 +147,35 @@ library StakingMessages {
      * +--------------+----------+----------+
      *                           | 37 bytes |
      *                           +----------+
+     *
+     * @param validationID The ID of the validation period.
+     * @param valid true if the validation period was registered, false if it was not and never will be.
+     * @return The packed message.
+     *
+     */
+    function packSubnetValidatorRegistrationMessage(
+        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;
+    }
+
+    /**
+     * @notice Unpacks a byte array as a SubnetValidatorRegistrationMessage message.
+     * The message format specification is the same as the one used in above for packing.
+     *
+     * @param input The byte array to unpack.
      * @return The validationID and whether or the validation period was registered
      * or is not a validator and never will be a validator to do the expiry time passing.
      */
@@ -127,6 +222,11 @@ library StakingMessages {
      * +--------------+----------+----------+
      *                           | 52 bytes |
      *                           +----------+
+     *
+     * @param validationID The ID of the validation period.
+     * @param nonce The nonce of the validation ID.
+     * @param weight The new weight of the validator.
+     * @return The packed message.
      */
     function packSetSubnetValidatorWeightMessage(
         bytes32 validationID,
@@ -156,6 +256,9 @@ library StakingMessages {
     /**
      * @notice Unpacks a byte array as a SetSubnetValidatorWeight message.
      * The message format specification is the same as the one used in above for packing.
+     *
+     * @param input The byte array to unpack.
+     * @return The validationID, nonce, and weight.
      */
     function unpackSetSubnetValidatorWeightMessage(bytes memory input)
         internal
@@ -196,7 +299,7 @@ library StakingMessages {
     }
 
     /**
-     * @notice Unpacks a byte array as a ValidationUptimeMessage.
+     * @notice Packs a ValidationUptimeMessage into a byte array.
      * The message format specification is:
      * +--------------+----------+----------+
      * |       typeID :   uint32 |  4 bytes |
@@ -207,6 +310,37 @@ library StakingMessages {
      * +--------------+----------+----------+
      *                           | 44 bytes |
      *                           +----------+
+     *
+     * @param validationID The ID of the validation period.
+     * @param uptime The uptime of the validator.
+     * @return The packed message.
+     */
+    function packValidationUptimeMessage(
+        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;
+    }
+
+    /**
+     * @notice Unpacks a byte array as a ValidationUptimeMessage.
+     * The message format specification is the same as the one used in above for packing.
+     *
+     * @param input The byte array to unpack.
+     * @return The validationID and uptime.
      */
     function unpackValidationUptimeMessage(bytes memory input)
         internal
@@ -256,6 +390,9 @@ library StakingMessages {
      * +-----------+----------+-----------+
      *                        | 144 bytes |
      *                        +-----------+
+     *
+     * @param validationInfo The information to pack.
+     * @return The validationID and the packed data.
      */
     function packValidationInfo(ValidationInfo memory validationInfo)
         internal
@@ -286,4 +423,57 @@ library StakingMessages {
         }
         return (sha256(res), res);
     }
+
+    /**
+     * @notice Unpacks a byte array as a ValidationInfo.
+     * The message format specification is the same as the one used in above for packing.
+     *
+     * @param input The byte array to unpack.
+     * @return The unpacked ValidationInfo.
+     */
+    function unpackValidationInfo(bytes memory input)
+        internal
+        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];
+        }
+
+        return ValidationInfo({
+            subnetID: subnetID,
+            nodeID: nodeID,
+            weight: weight,
+            registrationExpiry: expiry,
+            signature: signature
+        });
+    }
 }

contracts/staking/interfaces/IStakingManager.sol

@@ -5,6 +5,25 @@
 
 pragma solidity 0.8.25;
 
+import {StakingMessages} from "../StakingMessages.sol";
+import {IRewardCalculator} from "./IRewardCalculator.sol";
+
+struct InitialStakerInfo {
+    StakingMessages.ValidationInfo validationInfo;
+    address owner;
+}
+
+struct StakingManagerSettings {
+    bytes32 pChainBlockchainID;
+    bytes32 subnetID;
+    uint256 minimumStakeAmount;
+    uint256 maximumStakeAmount;
+    uint64 minimumStakeDuration;
+    uint8 maximumHourlyChurn;
+    InitialStakerInfo[] initialStakers;
+    IRewardCalculator rewardCalculator;
+}
+
 interface IStakingManager {
     /**
      * @notice Emitted when a new validation period is created by stake being locked in the manager contract.