@web3dotorg/evm-slc-core-contracts 0.3.2

package/interfaces/IWrappedToken.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+interface IWrappedToken is IERC20 {
+    function deposit() external payable returns (bool);
+}

package/libs/Errors.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+library Errors {
+    error InsufficientStakeAmount(
+        address subject,
+        uint256 requestedAmount,
+        uint256 availibleAmount
+    );
+    error InvalidStakeAmount(uint256 amount_);
+    error NotDAOSLC(address sender);
+    error ParameterIsNotSet(address parametersRegistry, string parameterName);
+    error InvalidParametersRegistry();
+    error NoRewardsAvailible(address subject);
+    error InvalidGovernance();
+    error InvalidERC20Token();
+    error SenderExpectedToBeDAOSLC(address sender);
+    error SenderExpectedToBeGovernance(address sender);
+    error ValueShouldBeInBasisPoints(uint256 value);
+    error ParameterIsNotSynced(string parameterName);
+    error ParameterIsAlreadySynced(string parameterName);
+}

package/libs/NeutralsSelection.sol

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {PRECISION} from "@solarity/solidity-lib/utils/Globals.sol";
+
+/// @dev The library is used for neutrals pseudo-random selection based on their stake
+library NeutralsSelection {
+    error CountOfAddressesMustBeTheSameAsWeights(uint256 addressesCount, uint256 weightsCount);
+    error KmustBeInRangeOfAddresesLength(uint256 k, uint256 addressesLength);
+
+    /// @param seed -- bytes, which is used as a seed
+    /// @return randomNumber -- uint256, which is a pseudo-random number in range [0, PRECISION)
+    function getRandomNumber(bytes memory seed) internal pure returns (uint256) {
+        return uint256(keccak256(seed)) % PRECISION;
+    }
+
+    function selectTopAddressesByWeight(
+        address[] memory addresses_,
+        uint256[] memory weights_,
+        uint256 k_
+    ) internal pure {
+        require(
+            addresses_.length == weights_.length,
+            CountOfAddressesMustBeTheSameAsWeights(addresses_.length, weights_.length)
+        );
+
+        require(
+            0 < k_ && k_ <= addresses_.length,
+            KmustBeInRangeOfAddresesLength(k_, addresses_.length)
+        );
+
+        _selectTop(addresses_, weights_, 0, addresses_.length - 1, k_);
+    }
+
+    function _selectTop(
+        address[] memory addresses_,
+        uint256[] memory weights_,
+        uint256 left_,
+        uint256 right_,
+        uint256 k_
+    ) private pure {
+        uint256 pivot_ = _partition(addresses_, weights_, left_, right_);
+        uint256 count_ = pivot_ - left_ + 1;
+
+        if (count_ == k_) {
+            return;
+        }
+
+        if (count_ < k_) {
+            _selectTop(addresses_, weights_, pivot_ + 1, right_, k_ - count_);
+        } else {
+            _selectTop(addresses_, weights_, left_, pivot_ - 1, k_);
+        }
+    }
+
+    function _partition(
+        address[] memory addresses_,
+        uint256[] memory weights_,
+        uint256 left_,
+        uint256 right_
+    ) private pure returns (uint256) {
+        uint256 pivot_ = weights_[right_];
+        uint256 i = left_;
+
+        for (uint256 j = left_; j < right_; ++j) {
+            if (weights_[j] > pivot_) {
+                (weights_[i], weights_[j]) = (weights_[j], weights_[i]);
+                (addresses_[i], addresses_[j]) = (addresses_[j], addresses_[i]);
+                ++i;
+            }
+        }
+
+        (weights_[i], weights_[right_]) = (weights_[right_], weights_[i]);
+        (addresses_[i], addresses_[right_]) = (addresses_[right_], addresses_[i]);
+
+        return i;
+    }
+}

package/mocks/Helper.sol

@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";

package/mocks/MockGovernance.sol

@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {IGovernance} from "../interfaces/IGovernance.sol";
+import {ERC165} from "@openzeppelin/contracts/utils/introspection/ERC165.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
+contract MockGovernance is IGovernance, ERC165 {
+    struct ServiceRequestCall {
+        address requester;
+        uint256 serviceFee;
+        uint256 neutralsNumber;
+        string additionalLink;
+        bytes data;
+    }
+
+    bool public _processServiceRequestResult;
+    ServiceRequestCall public _lastCall;
+    address public _systemToken;
+    address public _parametersRegistry;
+
+    function setProcessServiceRequestResult(bool result_) external {
+        _processServiceRequestResult = result_;
+    }
+
+    function setSystemToken(address token_) external {
+        _systemToken = token_;
+    }
+
+    function setParametersRegistry(address registry_) external {
+        _parametersRegistry = registry_;
+    }
+
+    function getSystemToken() external view override returns (address) {
+        return _systemToken;
+    }
+
+    function getParametersRegistry() external view override returns (address) {
+        return _parametersRegistry;
+    }
+
+    function processServiceRequest(
+        address requester_,
+        uint256 serviceFee_,
+        uint256 neutralsNumber_,
+        string memory additionalLink_,
+        bytes memory data_
+    ) external payable override returns (bool) {
+        _lastCall = ServiceRequestCall({
+            requester: requester_,
+            serviceFee: serviceFee_,
+            neutralsNumber: neutralsNumber_,
+            additionalLink: additionalLink_,
+            data: data_
+        });
+
+        return _processServiceRequestResult;
+    }
+
+    function proposeOperations(
+        uint256 proposalId_,
+        OperationBundle memory operationBundle_
+    ) external {}
+
+    function getLastProcessServiceRequestCall() external view returns (ServiceRequestCall memory) {
+        return _lastCall;
+    }
+
+    function supportsInterface(
+        bytes4 interfaceId
+    ) public view virtual override(ERC165, IERC165) returns (bool) {
+        return
+            interfaceId == type(IGovernance).interfaceId || super.supportsInterface(interfaceId);
+    }
+}

package/mocks/MockNeutralsRegistry.sol

@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {INeutralsRegistry} from "../interfaces/INeutralsRegistry.sol";
+
+/**
+ * @title MockNeutralsRegistry
+ * @notice Minimal mock for Governance/NeutralsRegistry tests
+ */
+contract MockNeutralsRegistry is INeutralsRegistry {
+    struct NeutralsInfo {
+        uint256 selfStake;
+        uint256 weight;
+        uint256 delegatedStake;
+        uint256 rewards;
+        uint256 delegationShare;
+        bool isActive;
+        bool isPaused;
+        string externalLink;
+    }
+
+    address private _governance;
+    address private _token;
+    address[] private _neutrals;
+    mapping(address => bool) private _isNeutral;
+    mapping(address => NeutralsInfo) private _neutralsInfo;
+
+    function setGovernance(address governance_) external {
+        _governance = governance_;
+    }
+
+    function setToken(address token_) external {
+        _token = token_;
+    }
+
+    function addNeutral(address neutral_, string calldata externalLink_) external {
+        if (!_isNeutral[neutral_]) {
+            _neutrals.push(neutral_);
+            _isNeutral[neutral_] = true;
+        }
+        _neutralsInfo[neutral_] = NeutralsInfo(0, 0, 0, 0, 0, true, false, externalLink_);
+    }
+
+    function addNeutrals(address[] memory neutrals_) external {
+        for (uint256 i = 0; i < neutrals_.length; i++) {
+            if (!_isNeutral[neutrals_[i]]) {
+                _neutrals.push(neutrals_[i]);
+                _isNeutral[neutrals_[i]] = true;
+            }
+            _neutralsInfo[neutrals_[i]] = NeutralsInfo(
+                0,
+                0,
+                0,
+                0,
+                0,
+                true,
+                false,
+                "http://test.neutral.me"
+            );
+        }
+    }
+
+    function removeNeutral(address neutral_) external {
+        if (!_isNeutral[neutral_]) return;
+        uint256 len = _neutrals.length;
+        for (uint256 i = 0; i < len; ++i) {
+            if (_neutrals[i] == neutral_) {
+                _neutrals[i] = _neutrals[len - 1];
+                _neutrals.pop();
+                break;
+            }
+        }
+        _isNeutral[neutral_] = false;
+        delete _neutralsInfo[neutral_];
+    }
+
+    function clearNeutrals() external {
+        for (uint256 i = 0; i < _neutrals.length; ++i) {
+            _isNeutral[_neutrals[i]] = false;
+            delete _neutralsInfo[_neutrals[i]];
+        }
+        delete _neutrals;
+    }
+
+    // --- INeutralsRegistry ---
+    function getNeutralsSlice(uint256 number_) external view override returns (address[] memory) {
+        uint256 n = _neutrals.length < number_ ? _neutrals.length : number_;
+        address[] memory slice = new address[](n);
+        for (uint256 i = 0; i < n; ++i) {
+            slice[i] = _neutrals[i];
+        }
+        return slice;
+    }
+
+    function getNeutralsCount() external view override returns (uint256) {
+        return _neutrals.length;
+    }
+
+    function isNeutral(address candidate_) external view override returns (bool) {
+        return _isNeutral[candidate_];
+    }
+
+    function slashNeutral(address neutral_, uint256 amount_) external override {
+        // no-op for mock
+    }
+
+    function distributeRewards(
+        address[] calldata selectedNeutrals_,
+        uint256 amount_
+    ) external override {
+        emit RewardsDistributed(selectedNeutrals_, amount_);
+    }
+
+    // --- Extra for tests ---
+    function getNeutralInfo(address candidate_) external view returns (NeutralsInfo memory) {
+        return _neutralsInfo[candidate_];
+    }
+
+    function getActiveNeutrals() external view returns (address[] memory) {
+        return _neutrals;
+    }
+
+    function supportsInterface(bytes4 interfaceId) public pure override returns (bool) {
+        return interfaceId == type(INeutralsRegistry).interfaceId || interfaceId == 0x01ffc9a7; // IERC165
+    }
+}

package/mocks/SimpleContract.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+contract SimpleContract {
+    uint256 public value;
+
+    function setValue(uint256 newValue_) external {
+        value = newValue_;
+    }
+
+    function getValue() external view returns (uint256) {
+        return value;
+    }
+}

package/mocks/WrappedToken.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+import {IWrappedToken} from "../interfaces/IWrappedToken.sol";
+
+contract WrappedToken is ERC20, IWrappedToken {
+    constructor() ERC20("Mock Wrapped Token", "MVT") {}
+
+    function mint(address to_, uint256 amount_) public {
+        _mint(to_, amount_);
+    }
+
+    function burn(address to_, uint256 amount_) public {
+        _burn(to_, amount_);
+    }
+
+    function deposit() external payable override returns (bool) {
+        mint(msg.sender, msg.value);
+
+        return true;
+    }
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@web3dotorg/evm-slc-core-contracts",
+  "version": "0.3.2",
+  "author": "<TBD>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/web3dotorg/evm-slc-core.git"
+  },
+  "homepage": "https://github.com/web3dotorg/evm-slc-core#readme",
+  "bugs": {
+    "url": "https://github.com/web3dotorg/evm-slc-core/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest"
+  },
+  "keywords": [
+    "solidity",
+    "smart-contracts",
+    "web3"
+  ],
+  "dependencies": {
+    "@openzeppelin/contracts": "5.3.0",
+    "@openzeppelin/contracts-upgradeable": "5.3.0",
+    "@solarity/solidity-lib": "3.1.1"
+  }
+}

package/slc-core/SLCCore.sol

@@ -0,0 +1,119 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {ERC165} from "@openzeppelin/contracts/utils/introspection/ERC165.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+
+import {ISLCCore} from "../interfaces/ISLCCore.sol";
+import {IGovernance} from "../interfaces/IGovernance.sol";
+
+contract SLCCore is ISLCCore, ERC165, Initializable {
+    struct SLCCoreStorage {
+        IGovernance governance;
+        // General SLC information
+        address slcCreator;
+        uint256 slcCreationTimestamp;
+        string legalDocumentLink;
+        bytes data;
+    }
+
+    // keccak256(abi.encode(uint256(keccak256("evm-slc-core.storage.SLCCore")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 private constant SLC_CORE_STORAGE_LOCATION =
+        0xf304ff929824090662a6977433af60f5d227e05590d7b320d3ccf44d6a708900;
+
+    receive() external payable {}
+
+    modifier onlyGovernance() {
+        _requireGovernance();
+        _;
+    }
+
+    constructor() {
+        _disableInitializers();
+    }
+
+    function __SLCCore_init(
+        address creator_,
+        address governance_,
+        string calldata legalDocumentLink_,
+        bytes calldata data_
+    ) external initializer {
+        SLCCoreStorage storage $ = _getSLCCoreStorage();
+
+        $.legalDocumentLink = legalDocumentLink_;
+        $.data = data_;
+        $.governance = IGovernance(governance_);
+
+        $.slcCreator = creator_;
+        $.slcCreationTimestamp = block.timestamp;
+
+        emit SLCInitialized(creator_, legalDocumentLink_);
+    }
+
+    function requestService(
+        uint256 serviceFee_,
+        uint256 neutralsNumber_,
+        string calldata additionalLink_,
+        bytes calldata data_
+    ) external payable virtual returns (bool) {
+        emit ServiceRequested(msg.sender, serviceFee_, neutralsNumber_, additionalLink_);
+
+        return
+            _getSLCCoreStorage().governance.processServiceRequest{value: msg.value}(
+                msg.sender,
+                serviceFee_,
+                neutralsNumber_,
+                additionalLink_,
+                data_
+            );
+    }
+
+    /* solhint-disable-next-line gas-calldata-parameters */
+    function arbitraryExecute(
+        IGovernance.OperationType operation_,
+        address to_,
+        bytes memory data_,
+        uint256 value_
+    ) external virtual onlyGovernance returns (bool success) {
+        if (data_.length == 0 && value_ == 0) return true;
+
+        if (operation_ == IGovernance.OperationType.DelegateCall) {
+            /* solhint-disable-next-line no-inline-assembly */
+            assembly ("memory-safe") {
+                success := delegatecall(gas(), to_, add(data_, 0x20), mload(data_), 0, 0)
+            }
+        } else {
+            /* solhint-disable-next-line no-inline-assembly */
+            assembly ("memory-safe") {
+                success := call(gas(), to_, value_, add(data_, 0x20), mload(data_), 0, 0)
+            }
+        }
+
+        require(success, FailedToExecuteArbitraryCall(operation_, to_, data_, value_));
+
+        emit ArbitraryExecute(operation_, to_, data_, value_);
+    }
+
+    function supportsInterface(
+        bytes4 interfaceId
+    ) public view override(IERC165, ERC165) returns (bool) {
+        return super.supportsInterface(interfaceId) || interfaceId == type(ISLCCore).interfaceId;
+    }
+
+    function getSLCCoreStorage() external pure returns (SLCCoreStorage memory) {
+        return _getSLCCoreStorage();
+    }
+
+    function _requireGovernance() internal view {
+        require(address(_getSLCCoreStorage().governance) == msg.sender, NotGovernance(msg.sender));
+    }
+
+    function _getSLCCoreStorage() private pure returns (SLCCoreStorage storage $) {
+        /* solhint-disable-next-line no-inline-assembly */
+        assembly ("memory-safe") {
+            $.slot := SLC_CORE_STORAGE_LOCATION
+        }
+    }
+}