WIP: Staking contract

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/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);
+    }
+}

contracts/validator-manager/PoAValidatorManager.sol

@@ -0,0 +1,61 @@
+// (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,
+    ValidatorRegistrationInput
+} 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(
+        ValidatorRegistrationInput calldata registrationInput,
+        uint64 weight
+    ) external onlyOwner returns (bytes32 validationID) {
+        return _initializeValidatorRegistration(registrationInput, weight);
+    }
+
+    // solhint-enable ordering
+    function initializeEndValidation(bytes32 validationID) external override onlyOwner {
+        _initializeEndValidation(validationID);
+    }
+
+    function completeEndValidation(uint32 messageIndex) external {
+        _completeEndValidation(messageIndex);
+    }
+}