Merge remote-tracking branch 'origin/main' into deployment-script

Author: michalinacienciala

contracts/governance/Checkpoints.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MIT
 
-pragma solidity ^0.8.0;
+pragma solidity 0.8.9;
 
 import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
 import "@openzeppelin/contracts/utils/math/Math.sol";

contracts/staking/IApplication.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-pragma solidity 0.8.4;
+pragma solidity 0.8.9;
 
 /// @title  Application interface for Threshold Network applications
 /// @notice Generic interface for an application. Application is an external
@@ -9,25 +9,25 @@ pragma solidity 0.8.4;
 ///         operator are eligible to slash the stake delegated to that operator.
 interface IApplication {
     /// @notice Used by T staking contract to inform the application that the
-    ///         authorized amount for the given operator increased. The
-    ///         application may do any necessary housekeeping.
-    function authorizationIncreased(address worker, uint256 amount) external;
+    ///         authorized amount for the given operator increased to the
+    ///         given amount. The application may do any necessary housekeeping.
+    function authorizationIncreased(address operator, uint96 amount) external;
 
     /// @notice Used by T staking contract to inform the application that the
     ///         given operator requested to decrease the authorization to the
     ///         given amount. The application should mark the authorization as
     ///         pending decrease and respond to the staking contract with
     ///         `approveAuthorizationDecrease` at its discretion. It may
     ///         happen right away but it also may happen several months later.
-    function authorizationDecreaseRequested(address worker, uint256 amount)
+    function authorizationDecreaseRequested(address operator, uint96 amount)
         external;
 
     /// @notice Used by T staking contract to inform the application the
     ///         authorization has been decreased for the given operator to the
     ///         given amount involuntarily, as a result of slashing. Lets the
     ///         application to do any housekeeping neccessary. Called with 250k
     ///         gas limit and does not revert the transaction if
-    ///         `involuntaryAllocationDecrease` call failed.
-    function involuntaryAllocationDecrease(address worker, uint256 amount)
+    ///         `involuntaryAuthorizationDecrease` call failed.
+    function involuntaryAuthorizationDecrease(address operator, uint96 amount)
         external;
 }

contracts/staking/ILegacyTokenStaking.sol

@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity 0.8.9;
+
+/// @title IKeepTokenStaking
+/// @notice Interface for Keep TokenStaking contract
+interface IKeepTokenStaking {
+    /// @notice Seize provided token amount from every member in the misbehaved
+    /// operators array. The tattletale is rewarded with 5% of the total seized
+    /// amount scaled by the reward adjustment parameter and the rest 95% is burned.
+    /// @param amountToSeize Token amount to seize from every misbehaved operator.
+    /// @param rewardMultiplier Reward adjustment in percentage. Min 1% and 100% max.
+    /// @param tattletale Address to receive the 5% reward.
+    /// @param misbehavedOperators Array of addresses to seize the tokens from.
+    function seize(
+        uint256 amountToSeize,
+        uint256 rewardMultiplier,
+        address tattletale,
+        address[] memory misbehavedOperators
+    ) external;
+
+    /// @notice Gets stake delegation info for the given operator.
+    /// @param operator Operator address.
+    /// @return amount The amount of tokens the given operator delegated.
+    /// @return createdAt The time when the stake has been delegated.
+    /// @return undelegatedAt The time when undelegation has been requested.
+    /// If undelegation has not been requested, 0 is returned.
+    function getDelegationInfo(address operator)
+        external
+        view
+        returns (
+            uint256 amount,
+            uint256 createdAt,
+            uint256 undelegatedAt
+        );
+
+    /// @notice Gets the stake owner for the specified operator address.
+    /// @return Stake owner address.
+    function ownerOf(address operator) external view returns (address);
+
+    /// @notice Gets the beneficiary for the specified operator address.
+    /// @return Beneficiary address.
+    function beneficiaryOf(address operator)
+        external
+        view
+        returns (address payable);
+
+    /// @notice Gets the authorizer for the specified operator address.
+    /// @return Authorizer address.
+    function authorizerOf(address operator) external view returns (address);
+
+    /// @notice Gets the eligible stake balance of the specified address.
+    /// An eligible stake is a stake that passed the initialization period
+    /// and is not currently undelegating. Also, the operator had to approve
+    /// the specified operator contract.
+    ///
+    /// Operator with a minimum required amount of eligible stake can join the
+    /// network and participate in new work selection.
+    ///
+    /// @param operator address of stake operator.
+    /// @param operatorContract address of operator contract.
+    /// @return balance an uint256 representing the eligible stake balance.
+    function eligibleStake(address operator, address operatorContract)
+        external
+        view
+        returns (uint256 balance);
+}
+
+/// @title INuCypherStakingEscrow
+/// @notice Interface for NuCypher StakingEscrow contract
+interface INuCypherStakingEscrow {
+    /// @notice Slash the staker's stake and reward the investigator
+    /// @param staker Staker's address
+    /// @param penalty Penalty
+    /// @param investigator Investigator
+    /// @param reward Reward for the investigator
+    function slashStaker(
+        address staker,
+        uint256 penalty,
+        address investigator,
+        uint256 reward
+    ) external;
+
+    /// @notice Request merge between NuCypher staking contract and T staking contract.
+    ///         Returns amount of staked tokens
+    function requestMerge(address staker, address operator)
+        external
+        returns (uint256);
+
+    /// @notice Get all tokens belonging to the staker
+    function getAllTokens(address staker) external view returns (uint256);
+}