fix(contracts): sizes (#195)

Author: mattstam

contracts/.gas-snapshot

@@ -15,11 +15,15 @@ exclude_lints = ["mixed-case-variable", "mixed-case-function", "screaming-snake-
 
 [profile.deploy]
 optimizer = true
-optimizer_runs = 200
+optimizer_runs = 188
+bytecode_hash = "none"
+cbor_metadata = false
 
 [profile.fuzz]
 optimizer = true
-optimizer_runs = 200
+optimizer_runs = 188
+bytecode_hash = "none"
+cbor_metadata = false
 runs = 10000
 seed = "0x1234"
 

contracts/foundry.toml

@@ -15,11 +15,6 @@ contract CreateProverAndStakeScript is BaseScript {
         uint256 STAKER_FEE_BIPS = 1000; // 10%
         uint256 STAKE_AMOUNT = 10_000e18;
 
-        // Ensure not already a prover owner
-        if (SuccinctStaking(STAKING).hasProver(msg.sender)) {
-            revert("Already a prover owner");
-        }
-
         // Ensure not already staked
         if (SuccinctStaking(STAKING).balanceOf(msg.sender) > 0) {
             revert("Already staked");

contracts/script/operations/CreateProverAndStake.s.sol

@@ -114,15 +114,15 @@ contract SuccinctStaking is
         uint256 _slashCancellationPeriod
     ) external initializer {
         // Ensure that parameters critical for functionality are non-zero.
-        if (
-            _owner == address(0) || _governor == address(0) || _vApp == address(0)
-                || _prove == address(0) || _intermediateProve == address(0) || _dispenser == address(0)
-        ) {
-            revert ZeroAddress();
-        }
-        if (_maxUnstakeRequests == 0 || _unstakePeriod == 0 || _slashCancellationPeriod == 0) {
-            revert ZeroAmount();
-        }
+        _requireNonZeroAddress(_owner);
+        _requireNonZeroAddress(_governor);
+        _requireNonZeroAddress(_vApp);
+        _requireNonZeroAddress(_prove);
+        _requireNonZeroAddress(_intermediateProve);
+        _requireNonZeroAddress(_dispenser);
+        _requireNonZeroNumber(_maxUnstakeRequests);
+        _requireNonZeroNumber(_unstakePeriod);
+        _requireNonZeroNumber(_slashCancellationPeriod);
 
         // Setup the initial state.
         __UUPSUpgradeable_init();
@@ -279,7 +279,7 @@ contract SuccinctStaking is
     /// @inheritdoc ISuccinctStaking
     function requestUnstake(uint256 _stPROVE) external override stakingOperation {
         // Ensure unstaking a non-zero amount.
-        if (_stPROVE == 0) revert ZeroAmount();
+        _requireNonZeroNumber(_stPROVE);
 
         // Get the prover that the staker is staked with.
         address prover = stakerToProver[msg.sender];
@@ -289,7 +289,7 @@ contract SuccinctStaking is
         if (unstakeClaims[msg.sender].length >= maxUnstakeRequests) revert TooManyUnstakeRequests();
 
         // Check that this prover is not in the process of being slashed.
-        if (slashClaimCount[prover] > 0) revert ProverHasSlashRequest();
+        _requireProverWithoutSlashRequests(prover);
 
         // Get the amount of $stPROVE this staker currently has.
         uint256 stPROVEBalance = balanceOf(msg.sender);
@@ -333,7 +333,7 @@ contract SuccinctStaking is
         if (claims.length == 0) revert NoUnstakeRequests();
 
         // Check that this prover is not in the process of being slashed.
-        if (slashClaimCount[prover] > 0) revert ProverHasSlashRequest();
+        _requireProverWithoutSlashRequests(prover);
 
         // Process the available unstake claims.
         PROVE += _finishUnstake(_staker, prover, claims);
@@ -367,7 +367,7 @@ contract SuccinctStaking is
         returns (uint256 index)
     {
         // Ensure slashing a non-zero amount.
-        if (_iPROVE == 0) revert ZeroAmount();
+        _requireNonZeroNumber(_iPROVE);
 
         // Create the slash claim.
         index = slashClaims[_prover].length;
@@ -496,7 +496,7 @@ contract SuccinctStaking is
         uint256 amount = _PROVE == type(uint256).max ? available : _PROVE;
 
         // Ensure dispensing a non-zero amount.
-        if (amount == 0) revert ZeroAmount();
+        _requireNonZeroNumber(amount);
 
         // If caller passed a specific number, make sure it doesn't exceed available.
         if (amount > available) revert AmountExceedsAvailableDispense();
@@ -532,7 +532,7 @@ contract SuccinctStaking is
         returns (uint256 stPROVE)
     {
         // Ensure staking a non-zero amount.
-        if (_PROVE == 0) revert ZeroAmount();
+        _requireNonZeroNumber(_PROVE);
 
         // Ensure the staking amount is greater than the minimum stake amount.
         if (_PROVE < minStakeAmount) revert StakeBelowMinimum();
@@ -541,7 +541,7 @@ contract SuccinctStaking is
         if (deactivatedProvers[_prover]) revert ProverNotActive();
 
         // Check that this prover is not in the process of being slashed.
-        if (slashClaimCount[_prover] > 0) revert ProverHasSlashRequest();
+        _requireProverWithoutSlashRequests(_prover);
 
         // Ensure the staker is not already staked with a different prover.
         address existingProver = stakerToProver[_staker];
@@ -663,6 +663,21 @@ contract SuccinctStaking is
         dispenseRate = _dispenseRate;
     }
 
+    /// @dev Thrown if a zero address is passed.
+    function _requireNonZeroAddress(address _address) internal pure {
+        if (_address == address(0)) revert ZeroAddress();
+    }
+
+    /// @dev Thrown if a zero number is passed.
+    function _requireNonZeroNumber(uint256 _number) internal pure {
+        if (_number == 0) revert ZeroAmount();
+    }
+
+    /// @dev Validates that a prover has no pending slash requests.
+    function _requireProverWithoutSlashRequests(address _prover) private view {
+        if (slashClaimCount[_prover] > 0) revert ProverHasSlashRequest();
+    }
+
     /// @dev Authorizes an ERC1967 proxy upgrade to a new implementation contract.
     function _authorizeUpgrade(address _newImplementation) internal override onlyOwner {}
 }

contracts/src/SuccinctStaking.sol

@@ -12,6 +12,7 @@ import {
     WithdrawAction,
     CreateProverAction
 } from "./libraries/PublicValues.sol";
+import {IProver} from "./interfaces/IProver.sol";
 import {ISuccinctVApp} from "./interfaces/ISuccinctVApp.sol";
 import {ISuccinctStaking} from "./interfaces/ISuccinctStaking.sol";
 import {ISP1Verifier} from "../lib/sp1-contracts/contracts/src/ISP1Verifier.sol";
@@ -201,7 +202,7 @@ contract SuccinctVApp is
     {
         // Validate.
         if (_owner == address(0)) revert ZeroAddress();
-        if (_owner != ISuccinctStaking(staking).ownerOf(_prover)) {
+        if (_owner != IProver(_prover).owner()) {
             revert ProverNotOwned();
         }
 

contracts/src/SuccinctVApp.sol

@@ -44,11 +44,6 @@ interface IProverRegistry {
     /// @notice The number of provers in the registry.
     function proverCount() external view returns (uint256);
 
-    /// @notice The owner of a given prover.
-    /// @param prover The address of the prover.
-    /// @return The address of the owner.
-    function ownerOf(address prover) external view returns (address);
-
     /// @notice Check if a given address is a prover.
     /// @dev This does not check if the prover is deactivated, use `isDeactivatedProver` to check
     ///      if the prover is deactivated.
@@ -68,11 +63,6 @@ interface IProverRegistry {
     /// @return The address of the prover.
     function getProver(address owner) external view returns (address);
 
-    /// @notice Check if a given address is the owner of a prover.
-    /// @param owner The address of the owner.
-    /// @return True if the address is the owner of a prover, false otherwise.
-    function hasProver(address owner) external view returns (bool);
-
     /// @notice Create a new prover.
     /// @dev The caller becomes the owner of the new prover. Only one prover can be created per
     ///      owner. It is recommended to use a cold wallet to create a prover, and then

contracts/src/interfaces/IProverRegistry.sol

@@ -77,11 +77,6 @@ abstract contract ProverRegistry is IProverRegistry {
         iProve = _iProve;
     }
 
-    /// @inheritdoc IProverRegistry
-    function ownerOf(address _prover) external view override returns (address) {
-        return IProver(_prover).owner();
-    }
-
     /// @inheritdoc IProverRegistry
     function isProver(address _prover) external view override returns (bool) {
         return provers[_prover];
@@ -97,18 +92,13 @@ abstract contract ProverRegistry is IProverRegistry {
         return ownerToProver[_owner];
     }
 
-    /// @inheritdoc IProverRegistry
-    function hasProver(address _owner) public view override returns (bool) {
-        return ownerToProver[_owner] != address(0);
-    }
-
     /// @inheritdoc IProverRegistry
     function createProver(uint256 _stakerFeeBips) external override returns (address) {
         if (_stakerFeeBips > 10000) {
             revert InvalidStakerFeeBips();
         }
 
-        if (hasProver(msg.sender)) {
+        if (ownerToProver[msg.sender] != address(0)) {
             revert ProverAlreadyExists();
         }
 

contracts/src/libraries/ProverRegistry.sol

@@ -82,7 +82,7 @@ contract SuccinctStakingRegistryTests is SuccinctStakingTest {
         vm.assume(_staker != address(0));
         vm.assume(_proverOwner != _staker);
         // Ensure these addresses don't already have provers
-        vm.assume(!SuccinctStaking(STAKING).hasProver(_proverOwner));
+        vm.assume(SuccinctStaking(STAKING).getProver(_proverOwner) == address(0));
         vm.assume(_staker != ALICE && _staker != BOB); // These already have provers from setup
 
         uint256 stakeAmount = bound(_stakeAmount, MIN_STAKE_AMOUNT, STAKER_PROVE_AMOUNT);

contracts/test/SuccinctStaking.registry.t.sol

@@ -320,15 +320,11 @@ contract SuccinctStakingSetupTests is SuccinctStakingTest {
         assertEq(ERC20(ALICE_PROVER).symbol(), "PROVER-1");
         assertEq(ERC20(BOB_PROVER).symbol(), "PROVER-2");
         assertEq(SuccinctStaking(STAKING).proverCount(), 2);
-        assertEq(SuccinctStaking(STAKING).ownerOf(ALICE_PROVER), ALICE);
-        assertEq(SuccinctStaking(STAKING).ownerOf(BOB_PROVER), BOB);
         assertEq(SuccinctStaking(STAKING).isProver(ALICE_PROVER), true);
         assertEq(SuccinctStaking(STAKING).isProver(BOB_PROVER), true);
         assertEq(SuccinctStaking(STAKING).isDeactivatedProver(ALICE_PROVER), false);
         assertEq(SuccinctStaking(STAKING).isDeactivatedProver(BOB_PROVER), false);
         assertEq(SuccinctStaking(STAKING).getProver(ALICE), ALICE_PROVER);
         assertEq(SuccinctStaking(STAKING).getProver(BOB), BOB_PROVER);
-        assertEq(SuccinctStaking(STAKING).hasProver(ALICE), true);
-        assertEq(SuccinctStaking(STAKING).hasProver(BOB), true);
     }
 }