@web3dotorg/evm-slc-core-contracts 0.3.2

package/governance/ParameterRegistry.sol

@@ -0,0 +1,381 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {ERC165} from "@openzeppelin/contracts/utils/introspection/ERC165.sol";
+import {ERC1967Utils} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol";
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+
+import {Paginator} from "@solarity/solidity-lib/libs/arrays/Paginator.sol";
+import {AMultiOwnable} from "@solarity/solidity-lib/access/AMultiOwnable.sol";
+import {DynamicSet} from "@solarity/solidity-lib/libs/data-structures/DynamicSet.sol";
+
+import {IQParameters} from "../interfaces/IQParameters.sol";
+
+/**
+ * @title ParameterRegistry
+ * @notice A multi-owner upgradeable contract for storing and retrieving various parameter types
+ */
+contract ParameterRegistry is IQParameters, ERC165, AMultiOwnable, UUPSUpgradeable {
+    using EnumerableSet for EnumerableSet.AddressSet;
+    using EnumerableSet for EnumerableSet.UintSet;
+    using EnumerableSet for EnumerableSet.Bytes32Set;
+    using DynamicSet for DynamicSet.StringSet;
+
+    // keccak256(abi.encode(uint256(keccak256("evm-slc-core.storage.ParameterRegistry")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 private constant PARAMETER_REGISTRY_STORAGE_LOCATION =
+        0xdb4673e5e220d5b2264587470c59af90d833b7a823651ce8108242ad38989400;
+
+    struct ParameterRegistryStorage {
+        // Mappings for fast lookups
+        mapping(string key => address value) addressParameters;
+        mapping(string key => uint256 value) uintParameters;
+        mapping(string key => string value) stringParameters;
+        mapping(string key => bytes32 value) bytes32Parameters;
+        // Sets for enumeration and pagination
+        DynamicSet.StringSet addressSet;
+        DynamicSet.StringSet uintSet;
+        DynamicSet.StringSet bytes32Set;
+        DynamicSet.StringSet stringSet;
+    }
+
+    struct AddressParameter {
+        string key;
+        address value;
+    }
+
+    struct UintParameter {
+        string key;
+        uint256 value;
+    }
+
+    struct StringParameter {
+        string key;
+        string value;
+    }
+
+    struct Bytes32Parameter {
+        string key;
+        bytes32 value;
+    }
+
+    enum ParameterType {
+        ADDRESS,
+        UINT,
+        STRING,
+        BYTES32
+    }
+
+    event AddressParameterSet(string indexed key, address indexed value);
+    event UintParameterSet(string indexed key, uint256 indexed value);
+    event StringParameterSet(string indexed key, string indexed value);
+    event Bytes32ParameterSet(string indexed key, bytes32 indexed value);
+
+    error ParameterNotFound(string key);
+
+    /**
+     * @notice Initialize the contract with initial owners
+     * @param initialOwners_ Array of initial owner addresses
+     */
+    function __ParameterRegistry_init(address[] calldata initialOwners_) external initializer {
+        __AMultiOwnable_init(initialOwners_);
+    }
+
+    /**
+     * @notice Set an address parameter
+     * @param key_ Parameter key
+     * @param value_ Address value to set
+     */
+    function setAddr(string calldata key_, address value_) external onlyOwner {
+        ParameterRegistryStorage storage $ = _getParameterRegistryStorage();
+        $.addressParameters[key_] = value_;
+        $.addressSet.add(key_);
+        emit AddressParameterSet(key_, value_);
+    }
+
+    function removeAddr(string calldata key_) external onlyOwner {
+        ParameterRegistryStorage storage $ = _getParameterRegistryStorage();
+        $.addressParameters[key_] = address(0);
+        $.addressSet.remove(key_);
+        emit AddressParameterSet(key_, address(0));
+    }
+
+    /**
+     * @notice Set a uint256 parameter
+     * @param key_ Parameter key
+     * @param value_ Uint256 value to set
+     */
+    function setUint(string calldata key_, uint256 value_) external onlyOwner {
+        ParameterRegistryStorage storage $ = _getParameterRegistryStorage();
+        $.uintParameters[key_] = value_;
+        $.uintSet.add(key_);
+        emit UintParameterSet(key_, value_);
+    }
+
+    function removeUint(string calldata key_) external onlyOwner {
+        ParameterRegistryStorage storage $ = _getParameterRegistryStorage();
+        $.uintParameters[key_] = 0;
+        $.uintSet.remove(key_);
+        emit UintParameterSet(key_, 0);
+    }
+
+    /**
+     * @notice Set a string parameter
+     * @param key_ Parameter key
+     * @param value_ String value to set
+     */
+    function setString(string calldata key_, string calldata value_) external onlyOwner {
+        ParameterRegistryStorage storage $ = _getParameterRegistryStorage();
+        $.stringParameters[key_] = value_;
+        $.stringSet.add(key_);
+        emit StringParameterSet(key_, value_);
+    }
+
+    function removeString(string calldata key_) external onlyOwner {
+        ParameterRegistryStorage storage $ = _getParameterRegistryStorage();
+        $.stringParameters[key_] = "";
+        $.stringSet.remove(key_);
+        emit StringParameterSet(key_, "");
+    }
+
+    /**
+     * @notice Set a bytes32 parameter
+     * @param key_ Parameter key
+     * @param value_ Bytes32 value to set
+     */
+    function setBytes32(string calldata key_, bytes32 value_) external onlyOwner {
+        ParameterRegistryStorage storage $ = _getParameterRegistryStorage();
+        $.bytes32Parameters[key_] = value_;
+        $.bytes32Set.add(key_);
+        emit Bytes32ParameterSet(key_, value_);
+    }
+
+    function removeBytes32(string calldata key_) external onlyOwner {
+        ParameterRegistryStorage storage $ = _getParameterRegistryStorage();
+        $.bytes32Parameters[key_] = bytes32(0);
+        $.bytes32Set.remove(key_);
+        emit Bytes32ParameterSet(key_, bytes32(0));
+    }
+
+    /**
+     * @inheritdoc IQParameters
+     */
+    function getAddr(string calldata key_) external view override returns (address) {
+        ParameterRegistryStorage storage $ = _getParameterRegistryStorage();
+
+        if (!$.addressSet.contains(key_)) {
+            revert ParameterNotFound(key_);
+        }
+
+        return $.addressParameters[key_];
+    }
+
+    /**
+     * @inheritdoc IQParameters
+     */
+    function getUint(string calldata key_) external view override returns (uint256) {
+        ParameterRegistryStorage storage $ = _getParameterRegistryStorage();
+
+        if (!$.uintSet.contains(key_)) {
+            revert ParameterNotFound(key_);
+        }
+
+        return $.uintParameters[key_];
+    }
+
+    /**
+     * @inheritdoc IQParameters
+     */
+    function getString(string calldata key_) external view override returns (string memory) {
+        ParameterRegistryStorage storage $ = _getParameterRegistryStorage();
+
+        if (!$.stringSet.contains(key_)) {
+            revert ParameterNotFound(key_);
+        }
+
+        return $.stringParameters[key_];
+    }
+
+    /**
+     * @inheritdoc IQParameters
+     */
+    function getBytes32(string calldata key_) external view override returns (bytes32) {
+        ParameterRegistryStorage storage $ = _getParameterRegistryStorage();
+
+        if (!$.bytes32Set.contains(key_)) {
+            revert ParameterNotFound(key_);
+        }
+
+        return $.bytes32Parameters[key_];
+    }
+
+    /**
+     * @notice Get paginated address parameters
+     * @param offset_ Starting index
+     * @param limit_ Number of items to return
+     * @return parameters Array of address parameters
+     */
+    function getAddressParameters(
+        uint256 offset_,
+        uint256 limit_
+    ) external view returns (AddressParameter[] memory parameters) {
+        ParameterRegistryStorage storage $ = _getParameterRegistryStorage();
+
+        uint256 to_ = Paginator.getTo($.addressSet.length(), offset_, limit_);
+        parameters = new AddressParameter[](to_ - offset_);
+
+        for (uint256 i = offset_; i < to_; ++i) {
+            string memory key_ = $.addressSet.at(i);
+            parameters[i - offset_] = AddressParameter({
+                key: key_,
+                value: $.addressParameters[key_]
+            });
+        }
+    }
+
+    /**
+     * @notice Get paginated uint256 parameters
+     * @param offset_ Starting index
+     * @param limit_ Number of items to return
+     * @return parameters Array of uint256 parameters
+     */
+    function getUintParameters(
+        uint256 offset_,
+        uint256 limit_
+    ) external view returns (UintParameter[] memory parameters) {
+        ParameterRegistryStorage storage $ = _getParameterRegistryStorage();
+
+        uint256 to_ = Paginator.getTo($.uintSet.length(), offset_, limit_);
+        parameters = new UintParameter[](to_ - offset_);
+
+        for (uint256 i = offset_; i < to_; ++i) {
+            string memory key_ = $.uintSet.at(i);
+            parameters[i - offset_] = UintParameter({key: key_, value: $.uintParameters[key_]});
+        }
+    }
+
+    /**
+     * @notice Get paginated string parameters
+     * @param offset_ Starting index
+     * @param limit_ Number of items to return
+     * @return parameters Array of string parameters
+     */
+    function getStringParameters(
+        uint256 offset_,
+        uint256 limit_
+    ) external view returns (StringParameter[] memory parameters) {
+        ParameterRegistryStorage storage $ = _getParameterRegistryStorage();
+
+        uint256 to_ = Paginator.getTo($.stringSet.length(), offset_, limit_);
+        parameters = new StringParameter[](to_ - offset_);
+
+        for (uint256 i = offset_; i < to_; ++i) {
+            string memory key_ = $.stringSet.at(i);
+            parameters[i - offset_] = StringParameter({
+                key: key_,
+                value: $.stringParameters[key_]
+            });
+        }
+    }
+
+    /**
+     * @notice Get paginated bytes32 parameters
+     * @param offset_ Starting index
+     * @param limit_ Number of items to return
+     * @return parameters Array of bytes32 parameters
+     */
+    function getBytes32Parameters(
+        uint256 offset_,
+        uint256 limit_
+    ) external view returns (Bytes32Parameter[] memory parameters) {
+        ParameterRegistryStorage storage $ = _getParameterRegistryStorage();
+
+        uint256 to_ = Paginator.getTo($.bytes32Set.length(), offset_, limit_);
+        parameters = new Bytes32Parameter[](to_ - offset_);
+
+        for (uint256 i = offset_; i < to_; ++i) {
+            string memory key_ = $.bytes32Set.at(i);
+            parameters[i - offset_] = Bytes32Parameter({
+                key: key_,
+                value: $.bytes32Parameters[key_]
+            });
+        }
+    }
+
+    /**
+     * @notice Get total count of parameters by type
+     * @return addressCount Number of address parameters
+     * @return uintCount Number of uint256 parameters
+     * @return stringCount Number of string parameters
+     * @return bytes32Count Number of bytes32 parameters
+     */
+    function getParameterCounts()
+        external
+        view
+        returns (
+            uint256 addressCount,
+            uint256 uintCount,
+            uint256 stringCount,
+            uint256 bytes32Count
+        )
+    {
+        ParameterRegistryStorage storage $ = _getParameterRegistryStorage();
+
+        addressCount = $.addressSet.length();
+        uintCount = $.uintSet.length();
+        stringCount = $.stringSet.length();
+        bytes32Count = $.bytes32Set.length();
+    }
+
+    /**
+     * @notice Check if a parameter exists for a given key and type
+     * @param key_ Parameter key
+     * @param paramType_ Parameter type
+     * @return exists True if parameter exists
+     */
+    function hasParameter(
+        string calldata key_,
+        ParameterType paramType_
+    ) external view returns (bool) {
+        ParameterRegistryStorage storage $ = _getParameterRegistryStorage();
+
+        if (paramType_ == ParameterType.ADDRESS) {
+            return $.addressParameters[key_] != address(0);
+        } else if (paramType_ == ParameterType.UINT) {
+            return $.uintParameters[key_] != 0;
+        } else if (paramType_ == ParameterType.STRING) {
+            return bytes($.stringParameters[key_]).length > 0;
+        }
+
+        return $.bytes32Parameters[key_] != bytes32(0);
+    }
+
+    /**
+     * @notice Check if contract supports a given interface
+     * @param interfaceId_ Interface ID to check
+     * @return True if interface is supported
+     */
+    function supportsInterface(bytes4 interfaceId_) public view override returns (bool) {
+        return
+            interfaceId_ == type(IQParameters).interfaceId ||
+            super.supportsInterface(interfaceId_);
+    }
+
+    function implementation() external view returns (address) {
+        return ERC1967Utils.getImplementation();
+    }
+
+    // solhint-disable-next-line no-empty-blocks
+    function _authorizeUpgrade(address newImplementation_) internal override onlyOwner {}
+
+    function _getParameterRegistryStorage()
+        private
+        pure
+        returns (ParameterRegistryStorage storage $)
+    {
+        // solhint-disable-next-line no-inline-assembly
+        assembly ("memory-safe") {
+            $.slot := PARAMETER_REGISTRY_STORAGE_LOCATION
+        }
+    }
+}

package/interfaces/IExecutorsRegistry.sol

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
+interface IExecutorsRegistry is IERC165 {
+    /**
+     * @notice Emitted when rewards are distributed to all executors
+     * @param totalAmount -- total amount of rewards that were distributed to all executors
+     */
+    event RewardsDistributed(uint256 totalAmount);
+
+    /**
+     * @notice Emitted when an executor is approved
+     * @param executor The address of the approved executor
+     */
+    event ExecutorApproved(address indexed executor);
+
+    /**
+     * @notice Emitted when an executor is disapproved
+     * @param executor The address of the disapproved executor
+     */
+    event ExecutorDisapproved(address indexed executor);
+
+    event ExecutorMovedToStandby(address indexed executor);
+    event RewardsClaimed(address indexed executor, uint256 amount);
+    event ExecutorActivated(address indexed executor, uint256 stake);
+    event ExecutorStaked(address indexed executor, uint256 amount, uint256 totalStake);
+    event ExecutorUnstaked(address indexed executor, uint256 amount, uint256 remainingStake);
+    event WithdrawalAnnounced(address indexed executor, uint256 amount, uint256 availableAt);
+    event WithdrawalCancelled(address indexed executor, uint256 amount);
+    event ExecutorPaused(address indexed executor);
+    event ExecutorUnpaused(address indexed executor);
+    event ExecutorSlashed(address indexed executor, uint256 amount, address recipient);
+
+    error ExecutorHasNoStake(address executor);
+    error ExecutorNotApproved(address executor);
+    error ExecutorAlreadyApproved(address executor);
+    error WithdrawalAlreadyAnnounced(address executor);
+    error NoWithdrawalAnnouncement(address executor);
+    error WithdrawalNotReady(address executor, uint256 availableAt);
+    error ExecutorAlreadyPaused(address executor);
+    error ExecutorNotPaused(address executor);
+    error InvalidInitialExecutor(address executor);
+
+    /**
+     * @return The number of active executors
+     */
+    function getExecutorsCount() external returns (uint256);
+
+    /**
+     * @param candidate_ The address of the candidate executor to check
+     * @return True if the candidate is an approved executor, false otherwise
+     */
+    function isExecutor(address candidate_) external returns (bool);
+
+    /**
+     * @notice Distribute rewards to all executors
+     * @param amount_ The amount of rewards to distribute to all executors
+     */
+    function distributeRewards(uint256 amount_) external;
+}

package/interfaces/IGovernance.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
+interface IGovernance is IERC165 {
+    enum OperationType {
+        Call,
+        DelegateCall
+    }
+
+    struct OperationData {
+        OperationType operation_;
+        address to_;
+        bytes data_;
+        uint256 value_;
+    }
+
+    struct OperationBundle {
+        OperationData[] operations;
+    }
+    /**
+     * @notice Initiates the process of resolving a service request
+     * @param requester_ The address of the requester
+     * @param serviceFee_ The fee for the service request. In case of pay with native token, should be equal to msg.value.
+     * @param neutralsNumber_ The number of neutrals which will be selected for resolving service request
+     * @param additionalLink_ The additional link for the service request
+     * @param data_ Additional data for the service request
+     */
+    function processServiceRequest(
+        address requester_,
+        uint256 serviceFee_,
+        uint256 neutralsNumber_,
+        string memory additionalLink_,
+        bytes memory data_
+    ) external payable returns (bool);
+
+    /**
+     * @notice Allow selected neutral to propose the operation
+     * @param proposalId_ The id of the target proposal
+     * @param operationBundle_ Proposed operation bundle
+     */
+    function proposeOperations(
+        uint256 proposalId_,
+        OperationBundle memory operationBundle_
+    ) external;
+
+    /**
+     * @return The address of the system token used for governance operations
+     */
+    function getSystemToken() external view returns (address);
+
+    /**
+     * @return The address of parameters registry
+     */
+    function getParametersRegistry() external view returns (address);
+}

package/interfaces/INeutralsRegistry.sol

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
+interface INeutralsRegistry is IERC165 {
+    event RewardsDistributed(address[] selectedNeutrals, uint256 totalAmount);
+    event NeutralMovedToStandby(address indexed neutral);
+    event RewardsClaimed(address indexed neutral, uint256 amount);
+    event NeutralActivated(address indexed neutral, uint256 stake);
+    event NeutralStaked(address indexed neutral, uint256 amount, uint256 totalStake);
+    event NeutralUnstaked(address indexed neutral, uint256 amount, uint256 remainingStake);
+    event WithdrawalAnnounced(address indexed neutral, uint256 amount, uint256 availableAt);
+    event WithdrawalCancelled(address indexed neutral, uint256 amount);
+    event NeutralPaused(address indexed neutral);
+    event NeutralUnpaused(address indexed neutral);
+    event DelegationWithdrawn(address delegator, address neutral, uint256 amount);
+    event NeutralSlashed(address indexed neutral, uint256 amount, address recipient);
+
+    error NeutralHasNoStake(address neutral);
+    error NeutralNotPaused(address neutral);
+    error NeutralAlreadyPaused(address neutral);
+    error InvalidDelegationAmount(uint256 amount);
+    error MaxDelegationAmplificationConstraintViolated(
+        uint256 requestedDelegation,
+        uint256 currentDelegatedStake,
+        uint256 maxPossibleDelegatedStake
+    );
+    error InsufficientDelegationAmount(
+        address delegator,
+        address neutral,
+        uint256 requested,
+        uint256 availible
+    );
+    error WithdrawalAlreadyAnnounced(address subject);
+    error NoWithdrawalAnnouncement(address subject);
+    error NeutralCannotDelegateToHimself(address subject);
+    error WithdrawalNotReady(address subject, uint256 availableAt);
+    error SelectedNeutralsNumberOutOfRange(uint256 providedNumber, uint256 activeNeutralsCount);
+
+    /**
+     * @param number_ The number of neutrals to select
+     * @return An array of addresses of selected neutrals based on their total stake
+     */
+    function getNeutralsSlice(uint256 number_) external view returns (address[] memory);
+
+    /**
+     * @notice Returns the number of active neutrals
+     * @return The number of active neutrals
+     */
+    function getNeutralsCount() external view returns (uint256);
+
+    /**
+     * @notice Checks if the provided address is active neutral(has enough stake)
+     * @param candidate_ The address of the candidate neutral to check
+     */
+    function isNeutral(address candidate_) external view returns (bool);
+
+    /**
+     * @notice Slashes the neutral by the specified amount of tokens
+     * @param neutral_ The neutral to be slashed
+     * @param amount_ The amount of tokens on which the neutral will be slashed
+     */
+    function slashNeutral(address neutral_, uint256 amount_) external;
+
+    /**
+     * @notice Distributes rewards to selected neutrals
+     * @param selectedNeutrals_ The addresses of the selected neutrals
+     * @param amount_ The amount of rewards to distribute to all neutrals
+     */
+    function distributeRewards(address[] calldata selectedNeutrals_, uint256 amount_) external;
+}

package/interfaces/IQParameters.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+/**
+ * @title Parameters interface for the Q System
+ * @notice Simplified version of the Q Parameters contract
+ * https://gitlab.com/q-dev/system-contracts/-/blob/master/contracts/governance/IParameters.sol
+ */
+interface IQParameters {
+    /**
+     * @notice Returns the address from the list by the given key, if it is in the list
+     * @param _key Parameter key
+     * @return address value
+     */
+    function getAddr(string calldata _key) external view returns (address);
+
+    /**
+     * @notice Returns uint256 from the list by the given key, if it is in the list
+     * @param _key Parameter key
+     * @return decimal number
+     */
+    function getUint(string calldata _key) external view returns (uint256);
+
+    /**
+     * @notice Returns a string from the list by the given key, if it is in the list
+     * @param _key Parameter key
+     * @return string value
+     */
+    function getString(string calldata _key) external view returns (string memory);
+
+    /**
+     * @notice Returns byte32 from the list by the given key, if it is in the list
+     * @param _key Parameter key
+     * @return byte32 value
+     */
+    function getBytes32(string calldata _key) external view returns (bytes32);
+}

package/interfaces/ISLCCore.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
+import {IGovernance} from "./IGovernance.sol";
+
+interface ISLCCore is IERC165 {
+    event SLCInitialized(address indexed creator, string legalDocumentLink);
+    event ServiceRequested(
+        address indexed requester,
+        uint256 indexed serviceFee,
+        uint256 indexed neutralsNumber,
+        string additionalLink
+    );
+    event ArbitraryExecute(
+        IGovernance.OperationType operation,
+        address to,
+        bytes data,
+        uint256 value
+    );
+
+    error NotGovernance(address sender);
+    error FailedToExecuteArbitraryCall(
+        IGovernance.OperationType operation,
+        address to,
+        bytes data,
+        uint256 value
+    );
+
+    /**
+     * @notice Request a service request from the SLC
+     * @param serviceFee_ The fee for the service request. In case of pay with native token, should be equal to msg.value.
+     * @param neutralsNumber_ The number of neutrals which will be selected for resolving service request
+     * @param additionalLink_ The additional link for the service request
+     * @param data_ Additional data for the service request
+     */
+    function requestService(
+        uint256 serviceFee_,
+        uint256 neutralsNumber_,
+        string memory additionalLink_,
+        bytes memory data_
+    ) external payable returns (bool);
+
+    /**
+     * @notice Execute code from SLC Core
+     * @param operation_ Operation type (Call or DelegateCall)
+     * @param to_ The address to which the operation will be executed
+     * @param data_ The data to be sent with the operation
+     * @param value_ The value to be sent with the operation
+     * @return True if the operation was executed successfully, false otherwise
+     */
+    function arbitraryExecute(
+        IGovernance.OperationType operation_,
+        address to_,
+        bytes memory data_,
+        uint256 value_
+    ) external returns (bool);
+}

package/interfaces/ISLCCoreFactory.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
+interface ISLCCoreFactory is IERC165 {
+    function deploySLC(string calldata legalDocumentLink_) external returns (address);
+
+    function deploySLCWithGovernance(
+        address governance_,
+        string calldata legalDocumentLink_
+    ) external returns (address);
+
+    function predictSLCAddress(
+        address slcDeployer_,
+        uint256 nonce_
+    ) external view returns (address);
+
+    function getDeployedSLCs(
+        uint256 offset_,
+        uint256 limit_
+    ) external view returns (address[] memory);
+
+    function getSalt(address slcDeployer_, uint256 nonce_) external pure returns (bytes32);
+
+    function isSLCCore(address toCheck_) external view returns (bool);
+
+    function nonces(address owner_) external view returns (uint256);
+}