Improved staking (new staking - part 2 - SWIP-20)

deploy/local/003_deploy_staking.ts

@@ -1,14 +1,15 @@
 import { DeployFunction } from 'hardhat-deploy/types';
 import { networkConfig } from '../../helper-hardhat-config';
 
 const func: DeployFunction = async function ({ deployments, getNamedAccounts, network, ethers }) {
   const { deploy, get, log } = deployments;
   const { deployer } = await getNamedAccounts();
   const swarmNetworkID = networkConfig[network.name]?.swarmNetworkId;
 
   const token = await get('TestToken');
+  const oracleAddress = (await get('PriceOracle')).address;
 
-  const args = [token.address, swarmNetworkID];
+  const args = [token.address, swarmNetworkID, oracleAddress];
   await deploy('StakeRegistry', {
     from: deployer,
     args: args,

deploy/main/003_deploy_staking.ts

@@ -6,13 +6,15 @@ const func: DeployFunction = async function ({ deployments, getNamedAccounts, ne
   const { deployer } = await getNamedAccounts();
   const swarmNetworkID = networkConfig[network.name]?.swarmNetworkId;
   const token = await get('Token');
-  let staking = null;
+  const oracleAddress = (await get('PriceOracle')).address;
 
-  // We use legacy token that was migrated, until we deploy new one with this framework
-  if (!(staking = await get('StakeRegistry'))) {
-  } else {
-    log('Using already deployed Staking at', staking.address);
-  }
+  const args = [token.address, swarmNetworkID, oracleAddress];
+  await deploy('StakeRegistry', {
+    from: deployer,
+    args: args,
+    log: true,
+    waitConfirmations: networkConfig[network.name]?.blockConfirmations || 6,
+  });
 
   log('----------------------------------------------------');
 };

deploy/test/003_deploy_staking.ts

@@ -6,8 +6,9 @@ const func: DeployFunction = async function ({ deployments, getNamedAccounts, ne
   const { deployer } = await getNamedAccounts();
   const swarmNetworkID = networkConfig[network.name]?.swarmNetworkId;
   const token = await get('TestToken');
+  const oracleAddress = (await get('PriceOracle')).address;
 
-  const args = [token.address, swarmNetworkID];
+  const args = [token.address, swarmNetworkID, oracleAddress];
   await deploy('StakeRegistry', {
     from: deployer,
     args: args,

src/Redistribution.sol

@@ -25,7 +25,7 @@ interface IStakeRegistry {
 
     function overlayOfAddress(address _owner) external view returns (bytes32);
 
-    function stakeOfAddress(address _owner) external view returns (uint256);
+    function nodeEffectiveStake(address _owner) external view returns (uint256);
 
     function getStakeStruct(address _owner) external view returns (Stake memory);
 }
@@ -155,9 +155,6 @@ contract Redistribution is AccessControl, Pausable {
     // The length of a round in blocks.
     uint256 private constant ROUND_LENGTH = 152;
 
-    // The miniumum stake allowed to be staked using the Staking contract.
-    uint64 private constant MIN_STAKE = 100000000000000000;
-
     // Maximum value of the keccack256 hash.
     bytes32 private constant MAX_H = 0x00000000000000000000000000000000ffffffffffffffffffffffffffffffff;
 
@@ -223,11 +220,11 @@ contract Redistribution is AccessControl, Pausable {
     error NotCommitPhase(); // Game is not in commit phase
     error NoCommitsReceived(); // Round didn't receive any commits
     error PhaseLastBlock(); // We don't permit commits in last block of the phase
-    error BelowMinimumStake(); // Node participating in game has stake below minimum treshold
     error CommitRoundOver(); // Commit phase in this round is over
     error CommitRoundNotStarted(); // Commit phase in this round has not started yet
     error NotMatchingOwner(); // Sender of commit is not matching the overlay address
     error MustStake2Rounds(); // Before entering the game node must stake 2 rounds prior
+    error NotStaked(); // Node didn't add any staking
     error WrongPhase(); // Checking in wrong phase, need to check duing claim phase of current round for next round or commit in current round
     error AlreadyCommited(); // Node already commited in this round
     error NotRevealPhase(); // Game is not in reveal phase
@@ -290,7 +287,7 @@ contract Redistribution is AccessControl, Pausable {
     function commit(bytes32 _obfuscatedHash, uint64 _roundNumber) external whenNotPaused {
         uint64 cr = currentRound();
         bytes32 _overlay = Stakes.overlayOfAddress(msg.sender);
-        uint256 _stake = Stakes.stakeOfAddress(msg.sender);
+        uint256 _stake = Stakes.nodeEffectiveStake(msg.sender);
 
         if (!currentPhaseCommit()) {
             revert NotCommitPhase();
@@ -307,8 +304,8 @@ contract Redistribution is AccessControl, Pausable {
             revert CommitRoundNotStarted();
         }
 
-        if (_stake < MIN_STAKE) {
-            revert BelowMinimumStake();
+        if (Stakes.lastUpdatedBlockNumberOfAddress(msg.sender) == 0) {
+            revert NotStaked();
         }
 
         if (Stakes.lastUpdatedBlockNumberOfAddress(msg.sender) >= block.number - 2 * ROUND_LENGTH) {
@@ -819,10 +816,6 @@ contract Redistribution is AccessControl, Pausable {
             revert MustStake2Rounds();
         }
 
-        if (Stakes.stakeOfAddress(_owner) < MIN_STAKE) {
-            revert BelowMinimumStake();
-        }
-
         return inProximity(Stakes.overlayOfAddress(_owner), currentRoundAnchor(), _depth);
     }
 

src/Staking.sol

@@ -4,6 +4,10 @@ import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import "@openzeppelin/contracts/access/AccessControl.sol";
 import "@openzeppelin/contracts/security/Pausable.sol";
 
+interface IPriceOracle {
+    function currentPrice() external view returns (uint32);
+}
+
 /**
  * @title Staking contract for the Swarm storage incentives
  * @author The Swarm Authors
@@ -19,7 +23,9 @@ contract StakeRegistry is AccessControl, Pausable {
         // Overlay of the node that is being staked
         bytes32 overlay;
         // Amount of tokens staked
-        uint256 stakeAmount;
+        uint256 commitedStake;
+        // Amount of tokens staked as potential stake
+        uint256 potentialStake;
         // Block height the stake was updated
         uint256 lastUpdatedBlockNumber;
         // Used to indicate presents in stakes struct
@@ -37,15 +43,27 @@ contract StakeRegistry is AccessControl, Pausable {
     // Swarm network ID
     uint64 NetworkId;
 
+    // The miniumum stake allowed to be staked using the Staking contract.
+    uint64 private constant MIN_STAKE = 100000000000000000;
+
     // Address of the staked ERC20 token
     address public immutable bzzToken;
 
+    // The address of the linked PriceOracle contract.
+    IPriceOracle public OracleContract;
+
     // ----------------------------- Events ------------------------------
 
     /**
-     * @dev Emitted when a stake is created or updated by `owner` of the `overlay` by `stakeamount`, during `lastUpdatedBlock`.
+     * @dev Emitted when a stake is created or updated by `owner` of the `overlay` by `commitedStake`, and `potentialStake` during `lastUpdatedBlock`.
      */
-    event StakeUpdated(address indexed owner, uint256 stakeAmount, bytes32 overlay, uint256 lastUpdatedBlock);
+    event StakeUpdated(
+        address indexed owner,
+        uint256 commitedStake,
+        uint256 potentialStake,
+        bytes32 overlay,
+        uint256 lastUpdatedBlock
+    );
 
     /**
      * @dev Emitted when a stake for address `slashed` is slashed by `amount`.
@@ -62,23 +80,30 @@ contract StakeRegistry is AccessControl, Pausable {
      */
     event OverlayChanged(address owner, bytes32 overlay);
 
+    /**
+     * @dev Emitted when a stake for address is withdrawn
+     */
+    event StakeWithdrawn(address node, uint256 amount);
+
     // ----------------------------- Errors ------------------------------
 
     error TransferFailed(); // Used when token transfers fail
     error Frozen(); // Used when an action cannot proceed because the overlay is frozen
     error Unauthorized(); // Used where only the owner can perform the action
     error OnlyRedistributor(); // Used when only the redistributor role is allowed
     error OnlyPauser(); // Used when only the pauser role is allowed
+    error BelowMinimumStake(); // Node participating in game has stake below minimum treshold
 
     // ----------------------------- CONSTRUCTOR ------------------------------
 
     /**
      * @param _bzzToken Address of the staked ERC20 token
      * @param _NetworkId Swarm network ID
      */
-    constructor(address _bzzToken, uint64 _NetworkId) {
+    constructor(address _bzzToken, uint64 _NetworkId, address _oracleContract) {
         NetworkId = _NetworkId;
         bzzToken = _bzzToken;
+        OracleContract = IPriceOracle(_oracleContract);
         _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
         _setupRole(PAUSER_ROLE, msg.sender);
     }
@@ -96,21 +121,35 @@ contract StakeRegistry is AccessControl, Pausable {
     function manageStake(bytes32 _setNonce, uint256 _addAmount) external whenNotPaused {
         bytes32 _previousOverlay = stakes[msg.sender].overlay;
         bytes32 _newOverlay = keccak256(abi.encodePacked(msg.sender, reverse(NetworkId), _setNonce));
+        uint256 _addPotentialStake = _addAmount;
+        uint256 _addCommitedStake = _addAmount / OracleContract.currentPrice(); // losing some decimals from start 10n16 is 99999999999984000
+
+        // First time adding stake, check the minimum is added
+        if (_addPotentialStake < MIN_STAKE && !stakes[msg.sender].isValue) {
+            revert BelowMinimumStake();
+        }
 
         if (stakes[msg.sender].isValue && !addressNotFrozen(msg.sender)) revert Frozen();
-        uint256 updatedAmount = stakes[msg.sender].isValue ? _addAmount + stakes[msg.sender].stakeAmount : _addAmount;
+        uint256 updatedPotentialStake = stakes[msg.sender].isValue
+            ? _addPotentialStake + stakes[msg.sender].potentialStake
+            : _addPotentialStake;
+
+        uint256 updatedCommitedStake = stakes[msg.sender].isValue
+            ? _addCommitedStake + stakes[msg.sender].commitedStake
+            : _addCommitedStake;
 
         stakes[msg.sender] = Stake({
             overlay: _newOverlay,
-            stakeAmount: updatedAmount,
+            commitedStake: updatedCommitedStake,
+            potentialStake: updatedPotentialStake,
             lastUpdatedBlockNumber: block.number,
             isValue: true
         });
 
         // Transfer tokens and emit event that stake has been updated
-        if (_addAmount > 0) {
-            if (!ERC20(bzzToken).transferFrom(msg.sender, address(this), _addAmount)) revert TransferFailed();
-            emit StakeUpdated(msg.sender, updatedAmount, _newOverlay, block.number);
+        if (_addPotentialStake > 0) {
+            if (!ERC20(bzzToken).transferFrom(msg.sender, address(this), _addPotentialStake)) revert TransferFailed();
+            emit StakeUpdated(msg.sender, updatedCommitedStake, updatedPotentialStake, _newOverlay, block.number);
         }
 
         // Emit overlay change event
@@ -120,23 +159,34 @@ contract StakeRegistry is AccessControl, Pausable {
     }
 
     /**
-     * @dev Withdraw stake only when the staking contract is paused,
-     * @param _amount The amount of ERC20 tokens to be withdrawn
+     * @dev Withdraw node stake surplus
      */
-    function withdrawFromStake(uint256 _amount) external whenPaused {
+    function withdrawFromStake() external {
         Stake memory stake = stakes[msg.sender];
 
-        // We cap the limit to not be over what is possible
-        uint256 withDrawLimit = (_amount > stake.stakeAmount) ? stake.stakeAmount : _amount;
-        stake.stakeAmount -= withDrawLimit;
+        uint256 _surplusStake = stake.potentialStake -
+            calculateEffectiveStake(stake.commitedStake, stake.potentialStake);
 
-        if (stake.stakeAmount == 0) {
-            delete stakes[msg.sender];
-        } else {
-            stakes[msg.sender].lastUpdatedBlockNumber = block.number;
+        if (_surplusStake > 0) {
+            stakes[msg.sender].potentialStake -= _surplusStake;
+            stakes[msg.sender].commitedStake -= _surplusStake / OracleContract.currentPrice();
+            if (!ERC20(bzzToken).transfer(msg.sender, _surplusStake)) revert TransferFailed();
+            emit StakeWithdrawn(msg.sender, _surplusStake);
         }
+    }
+
+    /**
+     * @dev Migrate stake only when the staking contract is paused,
+     * can only be called by the owner of the stake
+     */
+    function migrateStake() external whenPaused {
+        Stake memory stake = stakes[msg.sender];
 
-        if (!ERC20(bzzToken).transfer(msg.sender, withDrawLimit)) revert TransferFailed();
+        // We take out all the stake so user can migrate stake to other contract
+        if (stake.lastUpdatedBlockNumber != 0) {
+            if (!ERC20(bzzToken).transfer(msg.sender, stake.potentialStake)) revert TransferFailed();
+            delete stakes[msg.sender];
+        }
     }
 
     /**
@@ -162,8 +212,8 @@ contract StakeRegistry is AccessControl, Pausable {
         if (!hasRole(REDISTRIBUTOR_ROLE, msg.sender)) revert OnlyRedistributor();
 
         if (stakes[_owner].isValue) {
-            if (stakes[_owner].stakeAmount > _amount) {
-                stakes[_owner].stakeAmount -= _amount;
+            if (stakes[_owner].potentialStake > _amount) {
+                stakes[_owner].potentialStake -= _amount;
                 stakes[_owner].lastUpdatedBlockNumber = block.number;
             } else {
                 delete stakes[_owner];
@@ -209,20 +259,22 @@ contract StakeRegistry is AccessControl, Pausable {
     }
 
     /**
-     * @dev Returns the current `stakeAmount` of `address`.
+     * @dev Returns the current `effectiveStake` of `address`.
      * @param _owner _owner of node
      */
-    function stakeOfAddress(address _owner) public view returns (uint256) {
-        return stakes[_owner].stakeAmount;
+    function nodeEffectiveStake(address _owner) public view returns (uint256) {
+        Stake memory stake = stakes[_owner];
+        return calculateEffectiveStake(stake.commitedStake, stake.potentialStake);
     }
 
+    // TODO should we change this to effective stake?
     /**
-     * @dev Returns the current usable `stakeAmount` of `address`.
+     * @dev Returns the current usable `potentialStake` of `address`.
      * Checks whether the stake is currently frozen.
      * @param _owner owner of node
      */
     function usableStakeOfAddress(address _owner) public view returns (uint256) {
-        return addressNotFrozen(_owner) ? stakes[_owner].stakeAmount : 0;
+        return addressNotFrozen(_owner) ? stakes[_owner].potentialStake : 0;
     }
 
     /**
@@ -240,6 +292,21 @@ contract StakeRegistry is AccessControl, Pausable {
         return stakes[_owner].overlay;
     }
 
+    function calculateEffectiveStake(
+        uint256 committedStake,
+        uint256 potentialStakeBalance
+    ) internal view returns (uint256) {
+        // Calculate the product of committedStake and unitPrice to get price in BZZ
+        uint256 committedStakeBzz = committedStake * OracleContract.currentPrice();
+
+        // Return the minimum value between committedStakeBzz and potentialStakeBalance
+        if (committedStakeBzz < potentialStakeBalance) {
+            return committedStakeBzz;
+        } else {
+            return potentialStakeBalance;
+        }
+    }
+
     /**
      * @dev Please both Endians 🥚.
      * @param input Eth address used for overlay calculation.