RACE #41 Of The Secureum Bootcamp Epoch∞

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

import {ERC4626} from "@openzeppelin/contracts/token/ERC20/extensions/ERC4626.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "forge-std/console.sol";

contract VulnStake is ERC4626 {
   using Math for uint256;
   //
   address public underlying;

   // ACCESS CONTROL
   mapping(address operator => bool approved) public approvedOperators;

   // Stake & Shareholder Accounting Storage
   uint64 constant WAD = 1e18;
   uint32 public MIN_WITHDRAWAL_DELAY_BLOCKS = 56736;
   uint32 internal SLASHABLE_UNTIL = 50000;

   mapping(address operator => uint256 shares) public operatorShares;
   mapping(address operator => uint256 scalingFactor) public depositScalingFactor;
   mapping(address operator => uint256 scalingFactor) public slashingFactor;
   mapping(address operator => uint256 blockSlashableUntil) public slashableUntil;

   // Withdrawal Storage & Structs
   struct Withdrawal {
       address staker;
       uint32 startBlock;
       uint256 scaledShares;
       uint256 slashingFactorAtWithdrawal;
   }

   mapping(bytes32 withdrawalRoot => Withdrawal withdrawal) internal queuedWithdrawals;

   constructor(IERC20 _underlying, address[] memory _operators) ERC4626(_underlying) ERC20("vuln Stake", "VLNSTAKE") {
       underlying = address(_underlying);


       for(uint256 i = 0; i < _operators.length; i++) {
           approvedOperators[_operators[i]] = true;
       }
   }

   function registerOperator() public {
       address _operator = msg.sender;
       require(approvedOperators[_operator]);
       if(slashingFactor[_operator] == 0) {
           slashingFactor[_operator] = 1e18;
       }
   }

   function stake(uint256 assetAmount) public {
       address _operator = msg.sender;
       // set operator max magnitude and scaling factor
       if(operatorShares[_operator] == 0) {
           depositScalingFactor[_operator] = 1e18;
       }

       // calculate share
       uint256 shares = deposit(assetAmount, address(this));
       require(shares != 0, "non zero shares required");

       // Adjust DSF
       depositScalingFactor[_operator] = divWad(depositScalingFactor[_operator], slashingFactor[_operator]); // depositScalingFactor[_operator] * WAD / slashingFactor[_operator]

       // Increment operatorShares
       operatorShares[_operator] += shares;
   }

   function queueWithdrawal(uint256 _sharesToRemove) public {
       address _operator = msg.sender;
       require(_sharesToRemove <= operatorShares[_operator]);

       uint256 _slashedShares = mulWad(_sharesToRemove, slashingFactor[_operator]);
       uint256 _slashedScaledShares = mulWad(_slashedShares, depositScalingFactor[_operator]);

       Withdrawal memory _withdrawal = Withdrawal({
           staker: _operator,
           startBlock: uint32(block.number),
           scaledShares: _slashedScaledShares,
           slashingFactorAtWithdrawal: slashingFactor[_operator]
       });

       bytes32 _withdrawalRoot = calculateWithdrawalRoot(_withdrawal);

       queuedWithdrawals[_withdrawalRoot]  = _withdrawal;

       operatorShares[_operator] -= _sharesToRemove;

       if(operatorShares[_operator] == 0) slashableUntil[_operator] = block.number + SLASHABLE_UNTIL;
   }

   function completeWithdrawal(bytes32 _withdrawalRoot) public {
       Withdrawal memory _withdrawal = queuedWithdrawals[_withdrawalRoot];
       address withdrawer = _withdrawal.staker;

       require(withdrawer == msg.sender, "only withdrawable by staker");
       require(_withdrawal.startBlock != 0, "Already withdrawn");
       require(_withdrawal.startBlock + MIN_WITHDRAWAL_DELAY_BLOCKS > uint32(block.number), "MIN WITHDRAW NOT SATISFIED");

       // check slashing again
       uint256 slashingDelta = _withdrawal.slashingFactorAtWithdrawal - slashingFactor[withdrawer];
       uint256 sharesToWithdraw = slashingDelta == 0 ? _withdrawal.scaledShares : mulWad(_withdrawal.scaledShares, slashingDelta) ;

       // Prevent queued withdrawal running again
       queuedWithdrawals[_withdrawalRoot].startBlock  = 0;

       // burn withdrawable shares
       redeem(sharesToWithdraw, withdrawer, address(this));
   }

   function slash(uint256 wadsToSlash, address _operator) public {
       // check slashable until
       uint256 _slashableUntil = slashableUntil[_operator];

       if(_slashableUntil != 0) {
           require(_slashableUntil > block.number, "no longer slashable");
       }

       // decrement the slashing index
       slashingFactor[_operator] -= wadsToSlash;
   }

   function calculateWithdrawalRoot(
       Withdrawal memory withdrawal
   ) public pure returns (bytes32) {
       return keccak256(abi.encode(withdrawal));
   }

   function mulWad(uint256 x, uint256 y) internal pure returns (uint256) {
       return x.mulDiv(y, WAD);
   }

   function divWad(uint256 x, uint256 y) internal pure returns (uint256) {
       return x.mulDiv(WAD, y);
   }
}