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);
 }
@@ -45,7 +45,7 @@ interface IStakeRegistry {
  *
  * Once the _commit_ round has elapsed, participating nodes must provide the values used to calculate their obsfucated
  * _commit_ hash, which, once verified for correctness and proximity to the anchor are retained in the _currentReveals_.
- * Nodes that have commited but do not reveal the correct values used to create the pre-image will have their stake
+ * Nodes that have committed but do not reveal the correct values used to create the pre-image will have their stake
  * "frozen" for a period of rounds proportional to their reported depth.
  *
  * During the _reveal_ round, randomness is updated after every successful reveal. Once the reveal round is concluded,
@@ -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,13 +220,13 @@ 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 AlreadyCommitted(); // Node already committed in this round
     error NotRevealPhase(); // Game is not in reveal phase
     error OutOfDepthReveal(bytes32); // Anchor is out of reported depth in Reveal phase, anchor data available as argument
     error OutOfDepthClaim(uint8); // Anchor is out of reported depth in Claim phase, entryProof index is argument
@@ -290,7 +287,8 @@ 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);
+        uint256 _lastUpdate = Stakes.lastUpdatedBlockNumberOfAddress(msg.sender);
 
         if (!currentPhaseCommit()) {
             revert NotCommitPhase();
@@ -307,11 +305,11 @@ contract Redistribution is AccessControl, Pausable {
             revert CommitRoundNotStarted();
         }
 
-        if (_stake < MIN_STAKE) {
-            revert BelowMinimumStake();
+        if (_lastUpdate == 0) {
+            revert NotStaked();
         }
 
-        if (Stakes.lastUpdatedBlockNumberOfAddress(msg.sender) >= block.number - 2 * ROUND_LENGTH) {
+        if (_lastUpdate >= block.number - 2 * ROUND_LENGTH) {
             revert MustStake2Rounds();
         }
 
@@ -326,7 +324,7 @@ contract Redistribution is AccessControl, Pausable {
 
         for (uint256 i = 0; i < commitsArrayLength; ) {
             if (currentCommits[i].overlay == _overlay) {
-                revert AlreadyCommited();
+                revert AlreadyCommitted();
             }
 
             unchecked {
@@ -819,10 +817,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
@@ -18,8 +22,10 @@ contract StakeRegistry is AccessControl, Pausable {
     struct Stake {
         // Overlay of the node that is being staked
         bytes32 overlay;
-        // Amount of tokens staked
-        uint256 stakeAmount;
+        // Stake balance expressed through price oracle
+        uint256 committedStake;
+        // Stake balance expressed in BZZ
+        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 `committedStake`, and `potentialStake` during `lastUpdatedBlock`.
      */
-    event StakeUpdated(address indexed owner, uint256 stakeAmount, bytes32 overlay, uint256 lastUpdatedBlock);
+    event StakeUpdated(
+        address indexed owner,
+        uint256 committedStake,
+        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);
     }
@@ -91,26 +116,34 @@ contract StakeRegistry is AccessControl, Pausable {
      * @notice Create a new stake or update an existing one, change overlay of node
      * @dev At least `_initialBalancePerChunk*2^depth` number of tokens need to be preapproved for this contract.
      * @param _setNonce Nonce that was used for overlay calculation.
-     * @param _addAmount Deposited amount of ERC20 tokens.
+     * @param _addAmount Deposited amount of ERC20 tokens, equals to added Potential stake value
      */
     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 _addCommittedStake = _addAmount / OracleContract.currentPrice(); // losing some decimals from start 10n16 becomes 99999999999984000
+
+        // First time adding stake, check the minimum is added
+        if (_addAmount < 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 updatedCommittedStake = stakes[msg.sender].committedStake + _addCommittedStake;
+        uint256 updatedPotentialStake = stakes[msg.sender].potentialStake + _addAmount;
 
         stakes[msg.sender] = Stake({
             overlay: _newOverlay,
-            stakeAmount: updatedAmount,
+            committedStake: updatedCommittedStake,
+            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);
+            emit StakeUpdated(msg.sender, updatedCommittedStake, updatedPotentialStake, _newOverlay, block.number);
         }
 
         // Emit overlay change event
@@ -120,23 +153,29 @@ 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 {
-        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;
+    function withdrawFromStake() external {
+        uint256 _surplusStake = stakes[msg.sender].potentialStake -
+            calculateEffectiveStake(stakes[msg.sender].committedStake, stakes[msg.sender].potentialStake);
+
+        if (_surplusStake > 0) {
+            stakes[msg.sender].potentialStake -= _surplusStake;
+            if (!ERC20(bzzToken).transfer(msg.sender, _surplusStake)) revert TransferFailed();
+            emit StakeWithdrawn(msg.sender, _surplusStake);
+        }
+    }
 
-        if (stake.stakeAmount == 0) {
+    /**
+     * @dev Migrate stake only when the staking contract is paused,
+     * can only be called by the owner of the stake
+     */
+    function migrateStake() external whenPaused {
+        // We take out all the stake so user can migrate stake to other contract
+        if (lastUpdatedBlockNumberOfAddress(msg.sender) != 0) {
+            if (!ERC20(bzzToken).transfer(msg.sender, stakes[msg.sender].potentialStake)) revert TransferFailed();
             delete stakes[msg.sender];
-        } else {
-            stakes[msg.sender].lastUpdatedBlockNumber = block.number;
         }
-
-        if (!ERC20(bzzToken).transfer(msg.sender, withDrawLimit)) revert TransferFailed();
     }
 
     /**
@@ -162,8 +201,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 +248,23 @@ contract StakeRegistry is AccessControl, Pausable {
     }
 
     /**
-     * @dev Returns the current `stakeAmount` of `address`.
+     * @dev Returns the current `effectiveStake` of `address`. previously usable stake
      * @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) {
+        return
+            addressNotFrozen(_owner)
+                ? calculateEffectiveStake(stakes[_owner].committedStake, stakes[_owner].potentialStake)
+                : 0;
     }
 
     /**
-     * @dev Returns the current usable `stakeAmount` of `address`.
-     * Checks whether the stake is currently frozen.
-     * @param _owner owner of node
+     * @dev Check the amount that is possible to withdraw as surplus
      */
-    function usableStakeOfAddress(address _owner) public view returns (uint256) {
-        return addressNotFrozen(_owner) ? stakes[_owner].stakeAmount : 0;
+    function withdrawableStake() public view returns (uint256) {
+        return
+            stakes[msg.sender].potentialStake -
+            calculateEffectiveStake(stakes[msg.sender].committedStake, stakes[msg.sender].potentialStake);
     }
 
     /**
@@ -240,6 +282,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.