New simple SDK

foundry.toml

@@ -2,4 +2,5 @@
 src = "src"
 out = "out"
 libs = ["lib"]
+via_ir = true
 # See more config options https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#all-options

src/BLSKeyManager.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.25;
+
+import {Time} from "@openzeppelin/contracts/utils/types/Time.sol";
+
+import {MiddlewareStorage} from "./MiddlewareStorage.sol";
+import {ArrayWithTimes} from "./libraries/ArrayWithTimes.sol";
+
+abstract contract BLSKeyManager is MiddlewareStorage {
+    using ArrayWithTimes for ArrayWithTimes.Address;
+
+    error DuplicateBLSKey();
+
+    mapping(address => bytes) public blsKeys;
+    mapping(bytes => ArrayWithTimes.Address) internal blsKeyData;
+
+    function operatorByBLSKey(bytes memory key) public view returns (address) {
+        return blsKeyData[key].getAddress();
+    }
+
+    function operatorBLSKey(address operator) public view returns (bytes memory) {
+        return blsKeys[operator];
+    }
+
+    function blsKeyWasActiveAt(bytes memory key, uint48 timestamp) public view returns (bool) {
+        return blsKeyData[key].wasActiveAt(timestamp);
+    }
+
+    function updateBLSKey(address operator, bytes memory key) external onlyOwner {
+        if (blsKeyData[key].getAddress() != address(0)) {
+            revert DuplicateBLSKey();
+        }
+
+        blsKeys[operator] = key;
+        blsKeyData[key].set(operator);
+    }
+}

src/KeyManager.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.25;
+
+import {Time} from "@openzeppelin/contracts/utils/types/Time.sol";
+
+import {MiddlewareStorage} from "./MiddlewareStorage.sol";
+import {ArrayWithTimes} from "./libraries/ArrayWithTimes.sol";
+
+abstract contract KeyManager is MiddlewareStorage {
+    using ArrayWithTimes for ArrayWithTimes.Address;
+
+    error DuplicateKey();
+
+    mapping(address => bytes32) public keys;
+    mapping(bytes32 => ArrayWithTimes.Address) internal keyData;
+
+    function operatorByKey(bytes32 key) public view returns (address) {
+        return keyData[key].getAddress();
+    }
+
+    function operatorKey(address operator) public view returns (bytes32) {
+        return keys[operator];
+    }
+
+    function keyWasActiveAt(bytes32 key, uint48 timestamp) public view returns (bool) {
+        return keyData[key].wasActiveAt(timestamp);
+    }
+
+    function updateKey(address operator, bytes32 key) external onlyOwner {
+        if (keyData[key].getAddress() != address(0)) {
+            revert DuplicateKey();
+        }
+
+        keys[operator] = key;
+        keyData[key].set(operator);
+    }
+}

src/MiddlewareStorage.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.25;
+
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+
+abstract contract MiddlewareStorage is Ownable {
+    uint256 public subnetworks;
+
+    address public immutable NETWORK;
+    uint48 public immutable SLASHING_WINDOW;
+    address public immutable VAULT_REGISTRY;
+    address public immutable OPERATOR_REGISTRY;
+    address public immutable OPERATOR_NET_OPTIN;
+
+    uint64 public constant INSTANT_SLASHER_TYPE = 0;
+    uint64 public constant VETO_SLASHER_TYPE = 1;
+
+    constructor(
+        address owner,
+        address network,
+        uint48 slashingWindow,
+        address vaultRegistry,
+        address operatorRegistry,
+        address operatorNetOptIn
+    ) Ownable(owner) {
+        subnetworks = 1;
+
+        NETWORK = network;
+        SLASHING_WINDOW = slashingWindow;
+        VAULT_REGISTRY = vaultRegistry;
+        OPERATOR_REGISTRY = operatorRegistry;
+        OPERATOR_NET_OPTIN = operatorNetOptIn;
+    }
+}

src/OperatorManager.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.25;
+
+import {IRegistry} from "@symbiotic/interfaces/common/IRegistry.sol";
+import {IOptInService} from "@symbiotic/interfaces/service/IOptInService.sol";
+
+import {Time} from "@openzeppelin/contracts/utils/types/Time.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
+
+import {MiddlewareStorage} from "./MiddlewareStorage.sol";
+import {ArrayWithTimes} from "./libraries/ArrayWithTimes.sol";
+
+abstract contract OperatorManager is MiddlewareStorage {
+    using ArrayWithTimes for ArrayWithTimes.AddressArray;
+
+    error NotOperator();
+    error OperatorNotOptedIn();
+    error OperatorNotRegistered();
+    error OperatorAlreadyRegistred();
+
+    ArrayWithTimes.AddressArray internal operators;
+
+    function operatorsLength() external view returns (uint256) {
+        return operators.length();
+    }
+
+    function operatorWithTimesAt(uint256 pos) external view returns (address, uint48, uint48) {
+        return operators.at(pos);
+    }
+
+    function activeOperators(uint48 timestamp) public view returns (address[] memory) {
+        return operators.getActive(timestamp);
+    }
+
+    function registerOperator(address operator) external onlyOwner {
+        if (!IRegistry(OPERATOR_REGISTRY).isEntity(operator)) {
+            revert NotOperator();
+        }
+
+        if (!IOptInService(OPERATOR_NET_OPTIN).isOptedIn(operator, NETWORK)) {
+            revert OperatorNotOptedIn();
+        }
+
+        operators.register(operator);
+    }
+
+    function pauseOperator(address operator) external onlyOwner {
+        operators.pause(operator);
+    }
+
+    function unpauseOperator(address operator) external onlyOwner {
+        operators.unpause(operator, SLASHING_WINDOW);
+    }
+
+    function unregisterOperator(address operator) external onlyOwner {
+        operators.unregister(operator, SLASHING_WINDOW);
+    }
+}