feat: permissionless selfregistersqrttaskmiddleware

README.md

@@ -35,7 +35,7 @@ Below are examples of middleware implementations using different combinations of
 
 #### SimplePosMiddleware
 ```solidity
-contract SimplePosMiddleware is SharedVaults, Operators, KeyStorage256, OwnableAccessManager, EpochCapture, EqualStakePower {
+contract SimplePosMiddleware is SharedVaults, Operators, KeyManager256, OwnableAccessManager, EpochCapture, EqualStakePower {
     // Implementation details...
 }
 ```
@@ -49,7 +49,7 @@ Features:
 #### SqrtTaskMiddleware
 
 ```solidity
-contract SqrtTaskMiddleware is SharedVaults, Operators, NoKeyStorage, EIP712, OwnableAccessManager, TimestampCapture, EqualStakePower {
+contract SqrtTaskMiddleware is SharedVaults, Operators, NoKeyManager, EIP712, OwnableAccessManager, TimestampCapture, EqualStakePower {
     // Implementation details...
 }
 ```
@@ -63,7 +63,7 @@ Features:
 #### SelfRegisterMiddleware
 
 ```solidity
-contract SelfRegisterMiddleware is SharedVaults, SelfRegisterOperators, KeyStorage256, ECDSASig, NoAccessManager, TimestampCapture, EqualStakePower {
+contract SelfRegisterMiddleware is SharedVaults, SelfRegisterOperators, KeyManager256, ECDSASig, NoAccessManager, TimestampCapture, EqualStakePower {
     // Implementation details...
 }
 ```
@@ -77,7 +77,7 @@ Features:
 #### SelfRegisterEd25519Middleware
 
 ```solidity
-contract SelfRegisterEd25519Middleware is SharedVaults, SelfRegisterOperators, KeyStorage256, EdDSASig, NoAccessManager, TimestampCapture {
+contract SelfRegisterEd25519Middleware is SharedVaults, SelfRegisterOperators, KeyManager256, EdDSASig, NoAccessManager, TimestampCapture {
     // Implementation details...
 }
 ```
@@ -86,6 +86,18 @@ Features:
 
 - Similar to `SelfRegisterMiddleware` but uses Ed25519 keys and EdDSA signatures.
 
+#### SelfRegisterSqrtTaskMiddleware
+
+```solidity
+contract SelfRegisterSqrtTaskMiddleware is SharedVaults, SelfRegisterOperators, KeyManager256, ECDSASig, OwnableAccessManager, TimestampCapture, EqualStakePower {
+    // Implementation details...
+}
+```
+
+Features:
+
+- Similar to `SqrtTaskMiddleware` but allows self-registration of operators, permissionless shared vaults management and uses ECDSA signatures and keys.
+
 ## Getting Started
 
 To develop your middleware:

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

@@ -1,13 +1,16 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.25;
 
+import {INetworkRegistry} from "@symbiotic/interfaces/INetworkRegistry.sol";
 import {IVault} from "@symbiotic/interfaces/vault/IVault.sol";
 import {IBaseDelegator} from "@symbiotic/interfaces/delegator/IBaseDelegator.sol";
 import {Subnetwork} from "@symbiotic/contracts/libraries/Subnetwork.sol";
 
 import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
 import {SignatureChecker} from "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
 
+import {AccessManager} from "../../managers/extendable/AccessManager.sol";
+
 import {BaseMiddleware} from "../../middleware/BaseMiddleware.sol";
 import {SharedVaults} from "../../extensions/SharedVaults.sol";
 import {SelfRegisterOperators} from "../../extensions/operators/SelfRegisterOperators.sol";
@@ -48,31 +51,43 @@ contract SelfRegisterSqrtTaskMiddleware is
     Task[] public tasks;
 
     constructor(
-        address network,
+        address networkRegistry,
         uint48 slashingWindow,
         address operatorRegistry,
         address vaultRegistry,
         address operatorNetOptin,
         address reader,
         address owner
     ) {
-        initialize(network, slashingWindow, vaultRegistry, operatorRegistry, operatorNetOptin, reader, owner);
+        initialize(networkRegistry, slashingWindow, vaultRegistry, operatorRegistry, operatorNetOptin, reader, owner);
     }
 
     function initialize(
-        address network,
+        address networkRegistry,
         uint48 slashingWindow,
         address vaultRegistry,
         address operatorRegistry,
         address operatorNetOptin,
         address reader,
         address owner
     ) internal initializer {
-        __BaseMiddleware_init(network, slashingWindow, vaultRegistry, operatorRegistry, operatorNetOptin, reader);
+        INetworkRegistry(networkRegistry).registerNetwork();
+        __BaseMiddleware_init(address(this), slashingWindow, vaultRegistry, operatorRegistry, operatorNetOptin, reader);
         __OwnableAccessManager_init(owner);
         __SelfRegisterOperators_init("SelfRegisterSqrtTaskMiddleware");
     }
 
+    // allow anyone to register shared vaults
+    function _checkAccess() internal view override(AccessManager, OwnableAccessManager) {
+        if (
+            msg.sig == this.registerSharedVault.selector || msg.sig == this.unregisterSharedVault.selector
+                || msg.sig == this.pauseSharedVault.selector
+        ) {
+            return;
+        }
+        OwnableAccessManager._checkAccess();
+    }
+
     function createTask(uint256 value, address operator) external returns (uint256 taskIndex) {
         taskIndex = tasks.length;
         tasks.push(Task({captureTimestamp: getCaptureTimestamp(), value: value, operator: operator, completed: false}));
@@ -176,4 +191,14 @@ contract SelfRegisterSqrtTaskMiddleware is
     ) external checkAccess {
         _slashVault(epochStart, vault, subnetwork, operator, amount, hints);
     }
+
+    function _beforeRegisterSharedVault(
+        address sharedVault
+    ) internal override {
+        IBaseDelegator(IVault(sharedVault).delegator()).setMaxNetworkLimit(DEFAULT_SUBNETWORK, type(uint256).max);
+    }
+
+    function _beforeRegisterOperatorVault(address operator, address vault) internal override {
+        IBaseDelegator(IVault(vault).delegator()).setMaxNetworkLimit(DEFAULT_SUBNETWORK, type(uint256).max);
+    }
 }

src/managers/VaultManager.sol

@@ -83,7 +83,7 @@ abstract contract VaultManager is NetworkStorage, SlashingWindowStorage, Capture
         }
     }
 
-    uint96 private constant DEFAULT_SUBNETWORK = 0;
+    uint96 internal constant DEFAULT_SUBNETWORK = 0;
 
     /**
      * @notice Initializes the VaultManager with required parameters