WIP: Validator Manager contracts

contracts/mocks/ExampleERC20.sol

@@ -13,12 +13,13 @@ import {
     ERC20Burnable,
     ERC20
 } from "@openzeppelin/[email protected]/token/ERC20/extensions/ERC20Burnable.sol";
+import {IERC20Mintable} from "../validator-manager/interfaces/IERC20Mintable.sol";
 
-contract ExampleERC20 is ERC20Burnable {
+contract ExampleERC20 is ERC20Burnable, IERC20Mintable {
     string private constant _TOKEN_NAME = "Mock Token";
     string private constant _TOKEN_SYMBOL = "EXMP";
 
-    uint256 private constant _MAX_MINT = 1e16;
+    uint256 private constant _MAX_MINT = 1e19;
 
     constructor() ERC20(_TOKEN_NAME, _TOKEN_SYMBOL) {
         _mint(msg.sender, 1e28);
@@ -30,4 +31,11 @@ contract ExampleERC20 is ERC20Burnable {
 
         _mint(msg.sender, amount);
     }
+
+    function mint(address account, uint256 amount) external {
+        // Can only mint 10 at a time.
+        require(amount <= _MAX_MINT, "ExampleERC20: max mint exceeded");
+
+        _mint(account, amount);
+    }
 }

contracts/teleporter/README.md

@@ -69,7 +69,7 @@ Once sent on chain, Warp messages cannot be re-signed by a new validator set in
 
 **Do not deploy the `TeleporterMessenger` contract using `forge create`**. The `TeleporterMessenger` contract must be deployed to the same contract address on every chain. To achieve this, the contract can be deployed using a static transaction that uses Nick's method as documented in [this guide](../..//utils/contract-deployment/README.md). Alternatively, if creating a new Subnet, the contract can be pre-allocated with the proper address and state in the new chain's [genesis file](https://docs.avax.network/build/subnet/upgrade/customize-a-subnet#setting-the-genesis-allocation).
 
-As an example, to include `TeleporterMessenger` `v1.0.0` in the genesis file, include the following values in the `alloc` settings, as documented at the link above. The `storage` values included below correspond to the two contract values that are initialized as part of the default constructor of `TeleporterMessenger`. These are the `ReentrancyGuard` values set in this [abstract contract](../utilities/ReentrancyGuards.sol). Future versions of `TeleporterMessenger` may require different storage value intializations.
+As an example, to include `TeleporterMessenger` `v1.0.0` in the genesis file, include the following values in the `alloc` settings, as documented at the link above. The `storage` values included below correspond to the two contract values that are initialized as part of the default constructor of `TeleporterMessenger`. These are the `ReentrancyGuard` values set in this [abstract contract](../utilities/ReentrancyGuards.sol). Future versions of `TeleporterMessenger` may require different storage value initializations.
 ```json
 "alloc": {
     "0x253b2784c75e510dD0fF1da844684a1aC0aa5fcf": {

contracts/utilities/ICMInitializable.sol

@@ -0,0 +1,10 @@
+// (c) 2024, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+// SPDX-License-Identifier: Ecosystem
+pragma solidity 0.8.25;
+
+enum ICMInitializable {
+    Allowed,
+    Disallowed
+}

contracts/validator-manager/Delegation.md

@@ -0,0 +1,37 @@
+## Delegation
+
+`PoSValidatorManager` supports Delegation to an active Validator as a way for users to earn staking rewards without having to validate the chain. Delegators pay a configurable percentage fee on any earned staking rewards to the host Validator. Delegations are reflected on the P-Chain by adjusting the Validator's registered weight via a [`SetSubnetValidatorWeightTx`](https://github.com/avalanche-foundation/ACPs/tree/main/ACPs/77-reinventing-subnets#setsubnetvalidatorweighttx). The weight change acknowledgement is delivered to the `PoSValidatorManager` via a [`SubnetValidatorWeightUpdateMessage`](./README.md#subnetvalidatorweightupdatemessage). 
+
+> [!NOTE]
+> The P-Chain is only willing to sign a `SubnetValidatorWeightUpdateMessage` for an active Validator. Once Validator exit has been initiated (via a call to `initializeEndValidation`), the `PoSValidatorManager` must assume that the Validator has been deactivated on the P-Chain, and will therefore not sign any further weight updates. Therefore, it is invalid to _initiate_ adding or removing a Delegator when the Validator is in this state, though it _may be_ valid to _complete_ an already initiated Delegator action, depending on the order of delivery to the P-Chain. If the Delegator weight change was submitted (and a Warp signature on the acknowledgement retrieved) before the Validator was removed, then the Delegator action may be completed. Otherwise, the acknowledgement of the Validation end must first be delivered before completing the Delegator action. 
+
+The following state transition diagram illustrates the relationship between Validator and Delegator state. `Validator` is abbreviated as `V`, `Delegator` is abbreviated as `D`, and function names are shortened to improve readability. `Delegator.Completed` is omitted to show equivalance between the Validator's initial state and the state after a Delegation completes.
+```mermaid
+stateDiagram-v2
+    % Happy path
+    [*] --> V.PendingAdded : initAddVdr
+    V.PendingAdded --> V.Active : completeVdrReg
+    V.Active --> V.Active,D.PendingAdded : initAddDel
+    V.Active,D.PendingAdded --> V.Active,D.Active : completeAddDel
+    V.Active,D.Active --> V.Active,D.PendingRemoved : initEndDel
+    V.Active,D.PendingRemoved --> V.Active : completeEndDel
+    V.Active --> V.PendingRemoved : initEndVdr
+    V.PendingRemoved --> V.Completed : completeEndVdr
+
+    % Validator/Delegator state changes do not affect the Delegator/Validator state
+    V.Active,D.PendingRemoved --> V.PendingRemoved,D.PendingRemoved : initEndVdr
+    V.Active,D.PendingAdded --> V.PendingRemoved,D.PendingAdded : initEndVdr
+    V.Active,D.Active --> V.PendingRemoved,D.Active: initEndVdr
+
+    % When the Validator is in PendingRemoved or Completed, in general Delegator actions
+    % may be completed, but not initialized.
+    V.PendingRemoved,D.PendingAdded --> V.Completed,D.PendingAdded : completeEndVdr
+    V.PendingRemoved,D.PendingRemoved --> V.Completed,D.PendingRemoved : completeEndVdr
+    V.PendingRemoved,D.PendingRemoved --> V.PendingRemoved : completeEndDel
+    V.PendingRemoved,D.Active --> V.Completed,D.Active : completeEndVdr
+    % This is a no-op
+    V.PendingRemoved,D.PendingAdded --> V.PendingRemoved,D.Active : completeAddDel
+    V.Completed,D.PendingRemoved --> V.Completed : endDelegationCompletedValidator
+    V.Completed,D.Active --> V.Completed : endDelegationCompletedValidator
+    V.Completed,D.PendingAdded --> V.Completed : endDelegationCompletedValidator
+```

contracts/validator-manager/ERC20TokenStakingManager.sol

@@ -0,0 +1,132 @@
+// (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 {IERC20Mintable} from "./interfaces/IERC20Mintable.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";
+import {ValidatorRegistrationInput} from "./interfaces/IValidatorManager.sol";
+
+contract ERC20TokenStakingManager is
+    Initializable,
+    PoSValidatorManager,
+    IERC20TokenStakingManager
+{
+    using SafeERC20 for IERC20Mintable;
+    using SafeERC20TransferFrom for IERC20Mintable;
+
+    // solhint-disable private-vars-leading-underscore
+    /// @custom:storage-location erc7201:avalanche-icm.storage.ERC20TokenStakingManager
+    struct ERC20TokenStakingManagerStorage {
+        IERC20Mintable _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();
+        }
+    }
+
+    /**
+     * @notice Initialize the ERC20 token staking manager
+     * @dev Uses reinitializer(2) on the PoS staking contracts to make sure after migration from PoA, the PoS contracts can reinitialize with its needed values.
+     * @param settings Initial settings for the PoS validator manager
+     * @param token The ERC20 token to be staked
+     */
+    function initialize(
+        PoSValidatorManagerSettings calldata settings,
+        IERC20Mintable token
+    ) external reinitializer(2) {
+        __ERC20TokenStakingManager_init(settings, token);
+    }
+
+    // solhint-disable func-name-mixedcase
+    function __ERC20TokenStakingManager_init(
+        PoSValidatorManagerSettings calldata settings,
+        IERC20Mintable token
+    ) internal onlyInitializing {
+        __POS_Validator_Manager_init(settings);
+        __ERC20TokenStakingManager_init_unchained(token);
+    }
+
+    // solhint-disable func-name-mixedcase
+    function __ERC20TokenStakingManager_init_unchained(IERC20Mintable token)
+        internal
+        onlyInitializing
+    {
+        ERC20TokenStakingManagerStorage storage $ = _getERC20StakingManagerStorage();
+        if (address(token) == address(0)) {
+            revert InvalidAddress();
+        }
+        $._token = token;
+    }
+
+    /**
+     * @notice See {IERC20TokenStakingManager-initializeValidatorRegistration}
+     * Begins the validator registration process. Locks the configured ERC20 in the contract as the stake.
+     */
+    function initializeValidatorRegistration(
+        ValidatorRegistrationInput calldata registrationInput,
+        uint16 delegationFeeBips,
+        uint64 minStakeDuration,
+        uint256 stakeAmount
+    ) external nonReentrant returns (bytes32 validationID) {
+        return _initializeValidatorRegistration(
+            registrationInput, delegationFeeBips, minStakeDuration, stakeAmount
+        );
+    }
+
+    /**
+     * @notice Begins the delegator registration process. Locks the configured ERC20 in the contract as the delegated stake.
+     * @param validationID The ID of the validation period being delegated to.
+     * @param delegationAmount The amount to be delegated.
+     */
+    function initializeDelegatorRegistration(
+        bytes32 validationID,
+        uint256 delegationAmount
+    ) external nonReentrant returns (bytes32) {
+        return _initializeDelegatorRegistration(validationID, _msgSender(), delegationAmount);
+    }
+
+    // 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(address to, uint256 value) internal virtual override {
+        _getERC20StakingManagerStorage()._token.safeTransfer(to, value);
+    }
+
+    function _reward(address account, uint256 amount) internal virtual override {
+        ERC20TokenStakingManagerStorage storage $ = _getERC20StakingManagerStorage();
+        $._token.mint(account, amount);
+    }
+}

contracts/validator-manager/ExampleRewardCalculator.sol

@@ -0,0 +1,45 @@
+// (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;
+
+    uint8 public constant UPTIME_REWARDS_THRESHOLD_PERCENTAGE = 80;
+
+    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 validatorStartTime,
+        uint64 stakingStartTime,
+        uint64 stakingEndTime,
+        uint64 uptimeSeconds,
+        uint256, // initialSupply
+        uint256 // endSupply
+    ) external view returns (uint256) {
+        // Equivalent to uptimeSeconds/(validator.endedAt - validator.startedAt) < UPTIME_REWARDS_THRESHOLD_PERCENTAGE/100
+        // Rearranged to prevent integer division truncation.
+        if (
+            uptimeSeconds * 100
+                < (stakingEndTime - validatorStartTime) * UPTIME_REWARDS_THRESHOLD_PERCENTAGE
+        ) {
+            return 0;
+        }
+
+        return (stakeAmount * rewardBasisPoints * (stakingEndTime - stakingStartTime))
+            / SECONDS_IN_YEAR / 10000;
+    }
+}

contracts/validator-manager/NativeTokenStakingManager.sol

@@ -0,0 +1,95 @@
+// (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 {INativeMinter} from
+    "@avalabs/[email protected]/contracts/interfaces/INativeMinter.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";
+import {ValidatorRegistrationInput} from "./interfaces/IValidatorManager.sol";
+
+contract NativeTokenStakingManager is
+    Initializable,
+    PoSValidatorManager,
+    INativeTokenStakingManager
+{
+    using Address for address payable;
+
+    INativeMinter public constant NATIVE_MINTER =
+        INativeMinter(0x0200000000000000000000000000000000000001);
+
+    constructor(ICMInitializable init) {
+        if (init == ICMInitializable.Disallowed) {
+            _disableInitializers();
+        }
+    }
+
+    /**
+     * @notice Initialize the ERC20 token staking manager
+     * @dev Uses reinitializer(2) on the PoS staking contracts to make sure after migration from PoA, the PoS contracts can reinitialize with its needed values.
+     * @param settings Initial settings for the PoS validator manager
+     */
+    // solhint-disable ordering
+    function initialize(PoSValidatorManagerSettings calldata settings) external reinitializer(2) {
+        __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 See {INativeTokenStakingManager-initializeValidatorRegistration}.
+     * Begins the validator registration process. Locks the provided native asset in the contract as the stake.
+     */
+    function initializeValidatorRegistration(
+        ValidatorRegistrationInput calldata registrationInput,
+        uint16 delegationFeeBips,
+        uint64 minStakeDuration
+    ) external payable nonReentrant returns (bytes32) {
+        return _initializeValidatorRegistration(
+            registrationInput, delegationFeeBips, minStakeDuration, msg.value
+        );
+    }
+
+    /**
+     * @notice Begins the delegator registration process. Locks the provided native asset in the contract as the delegated stake.
+     * @param validationID The ID of the validation period being delegated to.
+     */
+    function initializeDelegatorRegistration(bytes32 validationID)
+        external
+        payable
+        nonReentrant
+        returns (bytes32)
+    {
+        return _initializeDelegatorRegistration(validationID, _msgSender(), msg.value);
+    }
+
+    // solhint-enable ordering
+    function _lock(uint256 value) internal virtual override returns (uint256) {
+        return value;
+    }
+
+    function _unlock(address to, uint256 value) internal virtual override {
+        payable(to).sendValue(value);
+    }
+
+    function _reward(address account, uint256 amount) internal virtual override {
+        NATIVE_MINTER.mintNativeCoin(account, amount);
+    }
+}