WIP: Staking contract

contracts/staking/ERC20TokenStakingManager.sol

@@ -0,0 +1,98 @@
+// (c) 2024, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+// SPDX-License-Identifier: Ecosystem
+
+pragma solidity 0.8.25;
+
+import {IERC20TokenStakingManager} from "./interfaces/IERC20TokenStakingManager.sol";
+import {Initializable} from
+    "@openzeppelin/[email protected]/proxy/utils/Initializable.sol";
+import {IERC20} from "@openzeppelin/[email protected]/token/ERC20/IERC20.sol";
+import {SafeERC20TransferFrom} from "@utilities/SafeERC20TransferFrom.sol";
+import {SafeERC20} from "@openzeppelin/[email protected]/token/ERC20/utils/SafeERC20.sol";
+import {ICMInitializable} from "../utilities/ICMInitializable.sol";
+import {PoSValidatorManager} from "./PoSValidatorManager.sol";
+import {PoSValidatorManagerSettings} from "./interfaces/IPoSValidatorManager.sol";
+
+contract ERC20TokenStakingManager is
+    Initializable,
+    PoSValidatorManager,
+    IERC20TokenStakingManager
+{
+    using SafeERC20 for IERC20;
+    using SafeERC20TransferFrom for IERC20;
+
+    // solhint-disable private-vars-leading-underscore
+    /// @custom:storage-location erc7201:avalanche-icm.storage.ERC20TokenStakingManager
+    struct ERC20TokenStakingManagerStorage {
+        IERC20 _token;
+        uint8 _tokenDecimals;
+    }
+    // solhint-enable private-vars-leading-underscore
+
+    // keccak256(abi.encode(uint256(keccak256("avalanche-icm.storage.ERC20TokenStakingManager")) - 1)) & ~bytes32(uint256(0xff));
+    // TODO: Update to correct storage slot
+    bytes32 private constant _ERC20_STAKING_MANAGER_STORAGE_LOCATION =
+        0x6e5bdfcce15e53c3406ea67bfce37dcd26f5152d5492824e43fd5e3c8ac5ab00;
+
+    // solhint-disable ordering
+    function _getERC20StakingManagerStorage()
+        private
+        pure
+        returns (ERC20TokenStakingManagerStorage storage $)
+    {
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+            $.slot := _ERC20_STAKING_MANAGER_STORAGE_LOCATION
+        }
+    }
+
+    constructor(ICMInitializable init) {
+        if (init == ICMInitializable.Disallowed) {
+            _disableInitializers();
+        }
+    }
+
+    function initialize(
+        PoSValidatorManagerSettings calldata settings,
+        IERC20 token
+    ) external initializer {
+        __ERC20TokenStakingManager_init(settings, token);
+    }
+
+    // solhint-disable func-name-mixedcase
+    function __ERC20TokenStakingManager_init(
+        PoSValidatorManagerSettings calldata settings,
+        IERC20 token
+    ) internal onlyInitializing {
+        __POS_Validator_Manager_init(settings);
+        __ERC20TokenStakingManager_init_unchained(token);
+    }
+
+    // solhint-disable func-name-mixedcase
+    function __ERC20TokenStakingManager_init_unchained(IERC20 token) internal onlyInitializing {
+        ERC20TokenStakingManagerStorage storage $ = _getERC20StakingManagerStorage();
+        require(address(token) != address(0), "ERC20TokenStakingManager: zero token address");
+        $._token = token;
+    }
+
+    function initializeValidatorRegistration(
+        uint256 stakeAmount,
+        bytes32 nodeID,
+        uint64 registrationExpiry,
+        bytes memory blsPublicKey
+    ) external override returns (bytes32 validationID) {
+        uint64 weight = _processStake(stakeAmount);
+        return _initializeValidatorRegistration(nodeID, weight, registrationExpiry, blsPublicKey);
+    }
+
+    // Must be guarded with reentrancy guard for safe transfer from
+    function _lock(uint256 value) internal virtual override returns (uint256) {
+        return _getERC20StakingManagerStorage()._token.safeTransferFrom(value);
+    }
+
+    function _unlock(uint256 value, address to) internal virtual override {
+        _getERC20StakingManagerStorage()._token.safeTransfer(to, value);
+    }
+}

contracts/staking/ExampleRewardCalculator.sol

@@ -0,0 +1,31 @@
+// (c) 2024, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+// SPDX-License-Identifier: Ecosystem
+
+pragma solidity 0.8.25;
+
+import {IRewardCalculator} from "./interfaces/IRewardCalculator.sol";
+
+contract ExampleRewardCalculator is IRewardCalculator {
+    uint256 public constant SECONDS_IN_YEAR = 31536000;
+
+    uint64 public immutable rewardBasisPoints;
+
+    constructor(uint64 rewardBasisPoints_) {
+        rewardBasisPoints = rewardBasisPoints_;
+    }
+
+    /**
+     * @notice A linear, non-compounding reward calculation that rewards a set percentage of tokens per year.
+     */
+    function calculateReward(
+        uint256 stakeAmount,
+        uint64 startTime,
+        uint64 endTime,
+        uint256, // initialSupply
+        uint256 // endSupply
+    ) external view returns (uint256) {
+        return (stakeAmount * rewardBasisPoints * (endTime - startTime)) / SECONDS_IN_YEAR / 1000;
+    }
+}

contracts/staking/NativeTokenStakingManager.sol

@@ -0,0 +1,74 @@
+// (c) 2024, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+// SPDX-License-Identifier: Ecosystem
+
+pragma solidity 0.8.25;
+
+import {INativeTokenStakingManager} from "./interfaces/INativeTokenStakingManager.sol";
+import {Address} from "@openzeppelin/[email protected]/utils/Address.sol";
+import {Initializable} from
+    "@openzeppelin/[email protected]/proxy/utils/Initializable.sol";
+import {ICMInitializable} from "../utilities/ICMInitializable.sol";
+import {PoSValidatorManager} from "./PoSValidatorManager.sol";
+import {PoSValidatorManagerSettings} from "./interfaces/IPoSValidatorManager.sol";
+
+contract NativeTokenStakingManager is
+    Initializable,
+    PoSValidatorManager,
+    INativeTokenStakingManager
+{
+    using Address for address payable;
+
+    constructor(ICMInitializable init) {
+        if (init == ICMInitializable.Disallowed) {
+            _disableInitializers();
+        }
+    }
+
+    // solhint-disable ordering
+    function initialize(PoSValidatorManagerSettings calldata settings) external initializer {
+        __NativeTokenStakingManager_init(settings);
+    }
+
+    // solhint-disable-next-line func-name-mixedcase
+    function __NativeTokenStakingManager_init(PoSValidatorManagerSettings calldata settings)
+        internal
+        onlyInitializing
+    {
+        __POS_Validator_Manager_init(settings);
+    }
+
+    // solhint-disable-next-line func-name-mixedcase, no-empty-blocks
+    function __NativeTokenStakingManager_init_unchained() internal onlyInitializing {}
+
+    /**
+     * @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.
+     * @param registrationExpiry The time at which the registration is no longer valid on the P-Chain.
+     * @param signature The raw bytes of the Ed25519 signature over the concatenated bytes of
+     * [subnetID]+[nodeID]+[blsPublicKey]+[weight]+[balance]+[expiry]. This signature must correspond to the Ed25519
+     * public key that is used for the nodeID. This approach prevents nodeIDs from being unwillingly added to Subnets.
+     * balance is the minimum initial $nAVAX balance that must be attached to the validator serialized as a uint64.
+     * 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,
+        bytes memory signature
+    ) external payable returns (bytes32) {
+        uint64 weight = _processStake(msg.value);
+
+        return _initializeValidatorRegistration(nodeID, weight, registrationExpiry, signature);
+    }
+
+    // solhint-enable ordering
+    function _lock(uint256 value) internal virtual override returns (uint256) {
+        return value;
+    }
+
+    function _unlock(uint256 value, address to) internal virtual override {
+        payable(to).sendValue(value);
+    }
+}

contracts/staking/PoAValidatorManager.sol

@@ -0,0 +1,56 @@
+// (c) 2024, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+// SPDX-License-Identifier: Ecosystem
+
+pragma solidity 0.8.25;
+
+import {IPoAValidatorManager} from "./interfaces/IPoAValidatorManager.sol";
+import {OwnableUpgradeable} from
+    "@openzeppelin/[email protected]/access/OwnableUpgradeable.sol";
+import {ICMInitializable} from "../utilities/ICMInitializable.sol";
+import {ValidatorManagerSettings} from "./interfaces/IValidatorManager.sol";
+import {ValidatorManager} from "./ValidatorManager.sol";
+
+contract PoAValidatorManager is IPoAValidatorManager, ValidatorManager, OwnableUpgradeable {
+    constructor(ICMInitializable init) {
+        if (init == ICMInitializable.Disallowed) {
+            _disableInitializers();
+        }
+    }
+
+    function initialize(
+        ValidatorManagerSettings calldata settings,
+        address initialOwner
+    ) external initializer {
+        __PoAValidatorManager_init(settings, initialOwner);
+    }
+
+    // solhint-disable func-name-mixedcase, ordering
+    function __PoAValidatorManager_init(
+        ValidatorManagerSettings calldata settings,
+        address initialOwner
+    ) internal onlyInitializing {
+        __ValidatorManager_init(settings);
+        __Ownable_init(initialOwner);
+    }
+
+    // solhint-disable-next-line no-empty-blocks
+    function __PoAValidatorManager_init_unchained() internal onlyInitializing {}
+
+    // solhint-enable func-name-mixedcase
+
+    function initializeValidatorRegistration(
+        uint64 weight,
+        bytes32 nodeID,
+        uint64 registrationExpiry,
+        bytes memory signature
+    ) external override onlyOwner returns (bytes32 validationID) {
+        return _initializeValidatorRegistration(nodeID, weight, registrationExpiry, signature);
+    }
+
+    // solhint-enable ordering
+    function initializeEndValidation(bytes32 validationID) external override {
+        _initializeEndValidation(validationID);
+    }
+}

contracts/staking/PoSValidatorManager.sol

@@ -0,0 +1,133 @@
+// (c) 2024, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+// SPDX-License-Identifier: Ecosystem
+
+pragma solidity 0.8.25;
+
+import {IPoSValidatorManager} from "./interfaces/IPoSValidatorManager.sol";
+import {PoSValidatorManagerSettings} from "./interfaces/IPoSValidatorManager.sol";
+import {ValidatorManager} from "./ValidatorManager.sol";
+import {WarpMessage} from
+    "@avalabs/[email protected]/contracts/interfaces/IWarpMessenger.sol";
+import {ValidatorMessages} from "./ValidatorMessages.sol";
+import {IRewardCalculator} from "./interfaces/IRewardCalculator.sol";
+
+abstract contract PoSValidatorManager is IPoSValidatorManager, ValidatorManager {
+    // solhint-disable private-vars-leading-underscore
+    /// @custom:storage-location erc7201:avalanche-icm.storage.PoSValidatorManager
+    struct PoSValidatorManagerStorage {
+        uint256 _minimumStakeAmount;
+        uint256 _maximumStakeAmount;
+        uint64 _minimumStakeDuration;
+        IRewardCalculator _rewardCalculator;
+        mapping(bytes32 validationID => uint64) _validatorUptimes;
+    }
+    // solhint-enable private-vars-leading-underscore
+
+    // keccak256(abi.encode(uint256(keccak256("avalanche-icm.storage.PoSValidatorManager")) - 1)) & ~bytes32(uint256(0xff));
+    // TODO: Unit test for storage slot and update slot
+    bytes32 private constant _POS_VALIDATOR_MANAGER_STORAGE_LOCATION =
+        0x4317713f7ecbdddd4bc99e95d903adedaa883b2e7c2551610bd13e2c7e473d00;
+
+    // solhint-disable ordering
+    function _getPoSValidatorManagerStorage()
+        private
+        pure
+        returns (PoSValidatorManagerStorage storage $)
+    {
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+            $.slot := _POS_VALIDATOR_MANAGER_STORAGE_LOCATION
+        }
+    }
+
+    // solhint-disable-next-line func-name-mixedcase
+    function __POS_Validator_Manager_init(PoSValidatorManagerSettings calldata settings)
+        internal
+        onlyInitializing
+    {
+        __ValidatorManager_init(settings.baseSettings);
+        __POS_Validator_Manager_init_unchained(
+            settings.minimumStakeAmount,
+            settings.maximumStakeAmount,
+            settings.minimumStakeDuration,
+            settings.rewardCalculator
+        );
+    }
+
+    // solhint-disable-next-line func-name-mixedcase
+    function __POS_Validator_Manager_init_unchained(
+        uint256 minimumStakeAmount,
+        uint256 maximumStakeAmount,
+        uint64 minimumStakeDuration,
+        IRewardCalculator rewardCalculator
+    ) internal onlyInitializing {
+        PoSValidatorManagerStorage storage s = _getPoSValidatorManagerStorage();
+        s._minimumStakeAmount = minimumStakeAmount;
+        s._maximumStakeAmount = maximumStakeAmount;
+        s._minimumStakeDuration = minimumStakeDuration;
+        s._rewardCalculator = rewardCalculator;
+    }
+
+    function initializeEndValidation(
+        bytes32 validationID,
+        bool includeUptimeProof,
+        uint32 messageIndex
+    ) external {
+        if (includeUptimeProof) {
+            PoSValidatorManagerStorage storage $ = _getPoSValidatorManagerStorage();
+            (WarpMessage memory warpMessage, bool valid) =
+                WARP_MESSENGER.getVerifiedWarpMessage(messageIndex);
+            require(valid, "PoSValidatorManager: invalid warp message");
+
+            require(
+                warpMessage.sourceChainID == WARP_MESSENGER.getBlockchainID(),
+                "PoSValidatorManager: invalid source chain ID"
+            );
+            require(
+                warpMessage.originSenderAddress == address(0),
+                "PoSValidatorManager: invalid origin sender address"
+            );
+
+            (bytes32 uptimeValidationID, uint64 uptime) =
+                ValidatorMessages.unpackValidationUptimeMessage(warpMessage.payload);
+            require(
+                validationID == uptimeValidationID,
+                "PoSValidatorManager: invalid uptime validation ID"
+            );
+
+            $._validatorUptimes[validationID] = uptime;
+            emit ValidationUptimeUpdated(validationID, uptime);
+        }
+
+        _initializeEndValidation(validationID);
+    }
+
+    function _processStake(uint256 stakeAmount) internal virtual returns (uint64) {
+        PoSValidatorManagerStorage storage $ = _getPoSValidatorManagerStorage();
+        // Lock the stake in the contract.
+        uint256 lockedValue = _lock(stakeAmount);
+
+        // Ensure the stake churn doesn't exceed the maximum churn rate.
+        uint64 weight = valueToWeight(lockedValue);
+        // Ensure the weight is within the valid range.
+
+        require(
+            weight >= $._minimumStakeAmount && weight <= $._maximumStakeAmount,
+            "PoSValidatorManager: invalid stake amount"
+        );
+        return weight;
+    }
+
+    function valueToWeight(uint256 value) public pure returns (uint64) {
+        return uint64(value / 1e12);
+    }
+
+    function weightToValue(uint64 weight) public pure returns (uint256) {
+        return uint256(weight) * 1e12;
+    }
+
+    function _lock(uint256 value) internal virtual returns (uint256);
+    function _unlock(uint256 value, address to) internal virtual;
+}