@towns-protocol/contracts 0.0.302

package/src/river/registry/facets/node/NodeRegistry.sol

@@ -0,0 +1,143 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {INodeRegistry} from "./INodeRegistry.sol";
+import {Node, NodeStatus} from "src/river/registry/libraries/RegistryStorage.sol";
+
+// libraries
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+
+import {RiverRegistryErrors} from "src/river/registry/libraries/RegistryErrors.sol";
+import {CustomRevert} from "src/utils/libraries/CustomRevert.sol";
+
+// contracts
+import {RegistryModifiers} from "src/river/registry/libraries/RegistryStorage.sol";
+
+contract NodeRegistry is INodeRegistry, RegistryModifiers {
+    using EnumerableSet for EnumerableSet.AddressSet;
+    using CustomRevert for string;
+
+    function isNode(address nodeAddress) public view returns (bool) {
+        return ds.nodeByAddress[nodeAddress].nodeAddress != address(0);
+    }
+
+    function registerNode(
+        address nodeAddress,
+        string memory url,
+        NodeStatus status
+    ) external onlyOperator(msg.sender) {
+        // validate that the node is not already in the registry
+        if (ds.nodeByAddress[nodeAddress].nodeAddress != address(0)) {
+            RiverRegistryErrors.ALREADY_EXISTS.revertWith();
+        }
+
+        Node memory newNode = Node({
+            nodeAddress: nodeAddress,
+            url: url,
+            status: status,
+            operator: msg.sender
+        });
+
+        ds.nodes.add(nodeAddress); // TODO: remove this line
+        ds.nodeByAddress[nodeAddress] = newNode;
+
+        emit NodeAdded(nodeAddress, msg.sender, url, status);
+    }
+
+    function removeNode(address nodeAddress) external onlyNodeOperator(nodeAddress, msg.sender) {
+        if (ds.nodeByAddress[nodeAddress].nodeAddress == address(0)) {
+            RiverRegistryErrors.NODE_NOT_FOUND.revertWith();
+        }
+
+        if (ds.nodeByAddress[nodeAddress].status != NodeStatus.Deleted) {
+            RiverRegistryErrors.NODE_STATE_NOT_ALLOWED.revertWith();
+        }
+
+        ds.nodes.remove(nodeAddress);
+        delete ds.nodeByAddress[nodeAddress];
+
+        emit NodeRemoved(nodeAddress);
+    }
+
+    function updateNodeStatus(
+        address nodeAddress,
+        NodeStatus status
+    )
+        external
+        onlyNode(nodeAddress)
+        onlyOperator(msg.sender)
+        onlyNodeOperator(nodeAddress, msg.sender)
+    {
+        Node storage node = ds.nodeByAddress[nodeAddress];
+
+        _checkNodeStatusTransionAllowed(node.status, status);
+
+        node.status = status;
+        emit NodeStatusUpdated(node.nodeAddress, status);
+    }
+
+    function updateNodeUrl(
+        address nodeAddress,
+        string memory url
+    )
+        external
+        onlyOperator(msg.sender)
+        onlyNode(nodeAddress)
+        onlyNodeOperator(nodeAddress, msg.sender)
+    {
+        Node storage node = ds.nodeByAddress[nodeAddress];
+
+        if (keccak256(abi.encodePacked(node.url)) == keccak256(abi.encodePacked(url))) {
+            RiverRegistryErrors.BAD_ARG.revertWith();
+        }
+
+        node.url = url;
+        emit NodeUrlUpdated(node.nodeAddress, url);
+    }
+
+    function getNode(address nodeAddress) external view returns (Node memory) {
+        // validate that the node is in the registry
+        if (!ds.nodes.contains(nodeAddress)) {
+            RiverRegistryErrors.NODE_NOT_FOUND.revertWith();
+        }
+
+        return ds.nodeByAddress[nodeAddress];
+    }
+
+    function getNodeCount() external view returns (uint256) {
+        return ds.nodes.length();
+    }
+
+    function getAllNodeAddresses() external view returns (address[] memory) {
+        return ds.nodes.values();
+    }
+
+    function getAllNodes() external view returns (Node[] memory) {
+        Node[] memory nodes = new Node[](ds.nodes.length());
+
+        for (uint256 i = 0; i < ds.nodes.length(); ++i) {
+            nodes[i] = ds.nodeByAddress[ds.nodes.at(i)];
+        }
+
+        return nodes;
+    }
+
+    function _checkNodeStatusTransionAllowed(NodeStatus from, NodeStatus to) internal pure {
+        if (
+            from == NodeStatus.NotInitialized ||
+            (from == NodeStatus.RemoteOnly &&
+                (to == NodeStatus.Failed ||
+                    to == NodeStatus.Departing ||
+                    to == NodeStatus.Operational)) ||
+            (from == NodeStatus.Operational &&
+                (to == NodeStatus.Failed || to == NodeStatus.Departing)) ||
+            (from == NodeStatus.Departing &&
+                (to == NodeStatus.Failed || to == NodeStatus.Deleted)) ||
+            (from == NodeStatus.Failed && to == NodeStatus.Deleted)
+        ) {
+            return;
+        }
+        RiverRegistryErrors.NODE_STATE_NOT_ALLOWED.revertWith();
+    }
+}

package/src/river/registry/facets/operator/IOperatorRegistry.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+interface IOperatorRegistry {
+    // =============================================================
+    //                           Events
+    // =============================================================
+    event OperatorAdded(address indexed operatorAddress);
+
+    event OperatorRemoved(address indexed operatorAddress);
+
+    // =============================================================
+    //                           Operators
+    // =============================================================
+    function approveOperator(address operator) external;
+
+    function removeOperator(address operator) external;
+
+    function isOperator(address operator) external view returns (bool);
+
+    function getAllOperators() external view returns (address[] memory);
+}

package/src/river/registry/facets/operator/OperatorRegistry.sol

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IOperatorRegistry} from "./IOperatorRegistry.sol";
+
+// libraries
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+
+import {RiverRegistryErrors} from "src/river/registry/libraries/RegistryErrors.sol";
+import {CustomRevert} from "src/utils/libraries/CustomRevert.sol";
+
+// contracts
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {OwnableBase} from "@towns-protocol/diamond/src/facets/ownable/OwnableBase.sol";
+import {RegistryModifiers} from "src/river/registry/libraries/RegistryStorage.sol";
+
+contract OperatorRegistry is IOperatorRegistry, RegistryModifiers, OwnableBase, Facet {
+    using EnumerableSet for EnumerableSet.AddressSet;
+    using CustomRevert for string;
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                       ADMIN FUNCTIONS                      */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function __OperatorRegistry_init(
+        address[] calldata initialOperators
+    ) external onlyInitializing {
+        for (uint256 i; i < initialOperators.length; ++i) {
+            _approveOperator(initialOperators[i]);
+        }
+    }
+
+    /// @inheritdoc IOperatorRegistry
+    function approveOperator(address operator) external onlyOwner {
+        _approveOperator(operator);
+    }
+
+    /// @inheritdoc IOperatorRegistry
+    function removeOperator(address operator) external onlyOwner {
+        if (!isOperator(operator)) {
+            RiverRegistryErrors.OPERATOR_NOT_FOUND.revertWith();
+        }
+
+        uint256 length = ds.nodes.length();
+        // verify that the operator has no nodes attached
+        for (uint256 i; i < length; ++i) {
+            if (ds.nodeByAddress[ds.nodes.at(i)].operator == operator) {
+                RiverRegistryErrors.OUT_OF_BOUNDS.revertWith();
+            }
+        }
+
+        ds.operators.remove(operator);
+
+        emit OperatorRemoved(operator);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          GETTERS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @inheritdoc IOperatorRegistry
+    function isOperator(address operator) public view returns (bool) {
+        return ds.operators.contains(operator);
+    }
+
+    /// @inheritdoc IOperatorRegistry
+    function getAllOperators() external view returns (address[] memory) {
+        return ds.operators.values();
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          INTERNAL                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function _approveOperator(address operator) internal {
+        // Validate operator address
+        if (operator == address(0)) RiverRegistryErrors.BAD_ARG.revertWith();
+
+        if (isOperator(operator)) RiverRegistryErrors.ALREADY_EXISTS.revertWith();
+
+        ds.operators.add(operator);
+
+        emit OperatorAdded(operator);
+    }
+}

package/src/river/registry/facets/stream/IStreamRegistry.sol

@@ -0,0 +1,184 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {SetMiniblock, SetStreamReplicationFactor, Stream, StreamWithId} from "src/river/registry/libraries/RegistryStorage.sol";
+
+// libraries
+
+// contracts
+
+interface IStreamRegistryBase {
+    /// @notice The type of stream event
+    enum StreamEventType {
+        Allocate,
+        Create,
+        PlacementUpdated,
+        LastMiniblockBatchUpdated
+    }
+
+    /// @notice The event emitted when a stream is updated
+    /// @dev One event to rule them all
+    /// To decode:
+    ///   switch (eventType) {
+    ///     case StreamEventType.Allocate:
+    ///     case StreamEventType.Create:
+    ///     case StreamEventType.PlacementUpdated:
+    ///       (bytes32 streamId, Stream memory stream) = abi.decode(data, (bytes32, Stream));
+    ///     case StreamEventType.LastMiniblockBatchUpdated:
+    ///       (SetMiniblock[] memory miniBlockUpdates) = abi.decode(data, (SetMiniblock[]));
+    ///   }
+    /// @param eventType The type of stream event
+    /// @param data The data of the stream event
+    event StreamUpdated(StreamEventType indexed eventType, bytes data);
+
+    event StreamLastMiniblockUpdateFailed(
+        bytes32 streamId,
+        bytes32 lastMiniblockHash,
+        uint64 lastMiniblockNum,
+        string reason
+    );
+}
+
+interface IStreamRegistry is IStreamRegistryBase {
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          STREAMS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /**
+     * @notice Allocate a new stream in the registry
+     * @param streamId The ID of the stream to allocate
+     * @param nodes The list of nodes to place the stream on
+     * @param genesisMiniblockHash The hash of the genesis miniblock
+     * @param genesisMiniblock The genesis miniblock data
+     * @dev Only callable by registered nodes
+     */
+    function allocateStream(
+        bytes32 streamId,
+        address[] memory nodes,
+        bytes32 genesisMiniblockHash,
+        bytes memory genesisMiniblock
+    ) external;
+
+    /**
+     * @notice Create a new stream in the registry
+     * @param stream is the Stream object to be created
+     * @dev Only callable by registered nodes
+     */
+    function addStream(
+        bytes32 streamId,
+        bytes32 genesisMiniblockHash,
+        Stream memory stream
+    ) external;
+
+    /**
+     * @notice Sync node addresses for streams in a range to `streamIdsByNode` mapping
+     * @param start The starting index for pagination
+     * @param stop The ending index for pagination, exclusive
+     */
+    function syncNodesOnStreams(uint256 start, uint256 stop) external;
+
+    /**
+     * @notice Set the last miniblock for multiple streams in a batch operation
+     * @param miniblocks Array of SetMiniblock structs containing stream IDs and their last
+     * miniblock
+     * information
+     * @dev Only callable by registered nodes
+     * @dev This function allows updating multiple streams' last miniblock data in a single
+     * transaction
+     */
+    function setStreamLastMiniblockBatch(SetMiniblock[] calldata miniblocks) external;
+
+    /**
+     * @notice Place a stream on a specific node
+     * @param streamId The ID of the stream to place
+     * @param nodeAddress The address of the node to place the stream on
+     */
+    function placeStreamOnNode(bytes32 streamId, address nodeAddress) external;
+
+    /**
+     * @notice Remove a stream from a specific node
+     * @param streamId The ID of the stream to remove
+     * @param nodeAddress The address of the node to remove the stream from
+     */
+    function removeStreamFromNode(bytes32 streamId, address nodeAddress) external;
+
+    /**
+     * @notice Set the replication factor for existing streams
+     * @param requests list with streams to set replication factor for
+     * @dev Only callable by configuration managers
+     *
+     * @dev This function is to migrate existing non-replicated streams to replicated streams.
+     * If the replication factor is less than the number of nodes it indicates that only the first
+     * "replicationFactor"
+     * nodes participate in reaching quorum. The remaining nodes only sync the stream data.
+     */
+    function setStreamReplicationFactor(SetStreamReplicationFactor[] calldata requests) external;
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          GETTERS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /**
+     * @notice Check if a stream exists in the registry
+     * @param streamId The ID of the stream to check
+     * @return bool True if the stream exists, false otherwise
+     */
+    function isStream(bytes32 streamId) external view returns (bool);
+
+    /**
+     * @notice Get a stream from the registry
+     * @param streamId The ID of the stream to get
+     * @return Stream The stream data
+     */
+    function getStream(bytes32 streamId) external view returns (Stream memory);
+
+    /**
+     * @notice Get a stream and its genesis information from the registry
+     * @param streamId The ID of the stream to get
+     * @return Stream The stream data
+     * @return bytes32 The genesis miniblock hash
+     * @return bytes The genesis miniblock data
+     */
+    function getStreamWithGenesis(
+        bytes32 streamId
+    ) external view returns (Stream memory, bytes32, bytes memory);
+
+    /**
+     * @notice Get the total number of streams in the registry
+     * @return uint256 The total number of streams
+     */
+    function getStreamCount() external view returns (uint256);
+
+    /**
+     * @notice Get the number of streams placed on a specific node
+     * @param nodeAddress The address of the node to check
+     * @return uint256 The number of streams on the node
+     */
+    function getStreamCountOnNode(address nodeAddress) external view returns (uint256);
+
+    /**
+     * @notice Get a paginated list of streams on a specific node
+     * @param nodeAddress The address of the node
+     * @param start The starting index for pagination
+     * @param stop The ending index for pagination, exclusive
+     * @return streams Array of streams with their IDs in the requested range for the specified node
+     */
+    function getPaginatedStreamsOnNode(
+        address nodeAddress,
+        uint256 start,
+        uint256 stop
+    ) external view returns (StreamWithId[] memory streams);
+    /**
+     * @notice Get a paginated list of streams from the registry
+     * @dev Recommended range is 5000 streams to avoid gas limits
+     * @param start The starting index for pagination
+     * @param stop The ending index for pagination, exclusive
+     * @return StreamWithId[] Array of streams with their IDs in the requested range
+     * @return bool True if this is the last page of results
+     */
+    function getPaginatedStreams(
+        uint256 start,
+        uint256 stop
+    ) external view returns (StreamWithId[] memory, bool);
+}