fix: rm approvalselfregisteroperators and add power threshold to selfregisteroperators

src/examples/self-register-network/SelfRegisterEd25519Middleware.sol

@@ -52,7 +52,7 @@ contract SelfRegisterEd25519Middleware is
         address owner
     ) internal initializer {
         __BaseMiddleware_init(network, slashingWindow, vaultRegistry, operatorRegistry, operatorNetOptin, reader);
-        __SelfRegisterOperators_init("SelfRegisterEd25519Middleware");
+        __SelfRegisterOperators_init("SelfRegisterEd25519Middleware", 0);
         __OwnableAccessManager_init(owner);
     }
 }

src/examples/self-register-network/SelfRegisterMiddleware.sol

@@ -52,7 +52,7 @@ contract SelfRegisterMiddleware is
         address owner
     ) internal initializer {
         __BaseMiddleware_init(network, slashingWindow, vaultRegistry, operatorRegistry, operatorNetOptIn, reader);
-        __SelfRegisterOperators_init("SelfRegisterMiddleware");
+        __SelfRegisterOperators_init("SelfRegisterMiddleware", 0);
         __OwnableAccessManager_init(owner);
     }
 }

src/examples/sqrt-task-network/SelfRegisterSqrtTaskMiddleware.sol

@@ -85,7 +85,7 @@ contract SelfRegisterSqrtTaskMiddleware is
         INetworkRegistry(networkRegistry).registerNetwork();
         __BaseMiddleware_init(address(this), slashingWindow, vaultRegistry, operatorRegistry, operatorNetOptin, reader);
         __OwnableAccessManager_init(owner);
-        __SelfRegisterOperators_init("SelfRegisterSqrtTaskMiddleware");
+        __SelfRegisterOperators_init("SelfRegisterSqrtTaskMiddleware", 0);
     }
 
     function createTask(uint256 value, address validator) external returns (uint256 taskIndex) {

src/extensions/operators/SelfRegisterOperators.sol

@@ -35,6 +35,7 @@ abstract contract SelfRegisterOperators is BaseOperators, SigManager, EIP712Upgr
         keccak256("UnpauseOperatorVault(address operator,address vault,uint256 nonce)");
 
     struct SelfRegisterOperatorsStorage {
+        uint256 minPower;
         mapping(address => uint256) nonces;
     }
 
@@ -49,27 +50,29 @@ abstract contract SelfRegisterOperators is BaseOperators, SigManager, EIP712Upgr
         }
     }
 
-    function nonces(
-        address operator
-    ) public view returns (uint256) {
-        return _getSelfRegisterOperatorsStorage().nonces[operator];
-    }
-
     /**
-     * @notice Initializes the contract with EIP712 domain separator
+     * @notice Initializes the contract with EIP712 domain separator and minimum power threshold
      * @param name The name to use for the EIP712 domain separator
+     * @param _minPower The minimum power threshold
      */
-    function __SelfRegisterOperators_init(
-        string memory name
-    ) internal onlyInitializing {
+    function __SelfRegisterOperators_init(string memory name, uint256 _minPower) internal onlyInitializing {
         __EIP712_init(name, "1");
+        SelfRegisterOperatorsStorage storage $ = _getSelfRegisterOperatorsStorage();
+        $.minPower = _minPower;
+    }
+
+    function nonces(
+        address operator
+    ) public view returns (uint256) {
+        return _getSelfRegisterOperatorsStorage().nonces[operator];
     }
 
     /**
      * @inheritdoc ISelfRegisterOperators
      */
     function registerOperator(bytes memory key, address vault, bytes memory signature) external virtual {
         _verifyKey(msg.sender, key, signature);
+        _checkMinPower(msg.sender, vault);
         _registerOperatorImpl(msg.sender, key, vault);
     }
 
@@ -84,6 +87,7 @@ abstract contract SelfRegisterOperators is BaseOperators, SigManager, EIP712Upgr
         bytes memory keySignature
     ) public virtual {
         _verifyKey(operator, key, keySignature);
+        _checkMinPower(operator, vault);
         SelfRegisterOperatorsStorage storage $ = _getSelfRegisterOperatorsStorage();
         _verifyEIP712(
             operator,
@@ -265,6 +269,21 @@ abstract contract SelfRegisterOperators is BaseOperators, SigManager, EIP712Upgr
         _unpauseOperatorVaultImpl(operator, vault);
     }
 
+    function _checkMinPower(address operator, address vault) internal view {
+        SelfRegisterOperatorsStorage storage $ = _getSelfRegisterOperatorsStorage();
+        address[] memory vaults = _activeVaults();
+        uint160[] memory subnetworks = _activeSubnetworks();
+        uint256 power = _getOperatorPower(operator, vaults, subnetworks);
+        if (address(vault) != address(0)) {
+            vaults = new address[](1);
+            vaults[0] = vault;
+            power += _getOperatorPower(operator, vaults, subnetworks);
+        }
+        if (power < $.minPower) {
+            revert NotEnoughPower();
+        }
+    }
+
     /**
      * @notice Verifies a key signature
      * @param operator The address of the operator

src/interfaces/extensions/operators/ISelfRegisterOperators.sol

@@ -7,6 +7,7 @@ pragma solidity ^0.8.25;
  */
 interface ISelfRegisterOperators {
     error InvalidSignature();
+    error NotEnoughPower();
 
     /**
      * @notice Returns the nonce for an operator address

src/managers/VaultManager.sol

@@ -65,7 +65,8 @@ abstract contract VaultManager is NetworkStorage, SlashingWindowStorage, Capture
     enum DelegatorType {
         FULL_RESTAKE,
         NETWORK_RESTAKE,
-        OPERATOR_SPECIFIC
+        OPERATOR_SPECIFIC,
+        OPERATOR_NETWORK_SPECIFIC
     }
 
     // keccak256(abi.encode(uint256(keccak256("symbiotic.storage.VaultManager")) - 1)) & ~bytes32(uint256(0xff))
@@ -733,8 +734,10 @@ abstract contract VaultManager is NetworkStorage, SlashingWindowStorage, Capture
     function _validateOperatorVault(address operator, address vault) internal view {
         address delegator = IVault(vault).delegator();
         if (
-            IEntity(delegator).TYPE() != uint64(DelegatorType.OPERATOR_SPECIFIC)
-                || IOperatorSpecificDelegator(delegator).operator() != operator
+            (
+                IEntity(delegator).TYPE() != uint64(DelegatorType.OPERATOR_SPECIFIC)
+                    && IEntity(delegator).TYPE() != uint64(DelegatorType.OPERATOR_NETWORK_SPECIFIC)
+            ) || IOperatorSpecificDelegator(delegator).operator() != operator
         ) {
             revert NotOperatorSpecificVault();
         }