@web3dotorg/evm-slc-core-contracts 0.3.2

package/slc-core/SLCCoreFactory.sol

@@ -0,0 +1,215 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
+import {ERC165} from "@openzeppelin/contracts/utils/introspection/ERC165.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {ERC1967Utils} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol";
+import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+import {UUPSUpgradeable} from "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+
+import {SLCCore} from "./SLCCore.sol";
+
+import {ISLCCoreFactory} from "../interfaces/ISLCCoreFactory.sol";
+import {INeutralsRegistry} from "../interfaces/INeutralsRegistry.sol";
+import {IExecutorsRegistry} from "../interfaces/IExecutorsRegistry.sol";
+import {IQParameters} from "../interfaces/IQParameters.sol";
+
+/**
+ * @title SLCCoreFactory
+ * @notice Factory contract for deploying SLC Core contracts
+ */
+contract SLCCoreFactory is ISLCCoreFactory, ERC165, OwnableUpgradeable, UUPSUpgradeable {
+    using EnumerableSet for EnumerableSet.AddressSet;
+
+    /// @custom:storage-location erc7201:slc-core-poc.storage.SLCFactory
+    struct SLCFactoryStorage {
+        INeutralsRegistry neutralsRegistry;
+        IExecutorsRegistry executorsRegistry;
+        IQParameters parametersRegistry;
+        address slcCoreImplementation;
+        EnumerableSet.AddressSet deployedSLCs;
+        mapping(address => uint256) nonces;
+    }
+
+    struct SLCFactoryStorageData {
+        address parametersRegistry;
+        address slcCoreImplementation;
+    }
+
+    // keccak256(abi.encode(uint256(keccak256("slc-core-poc.storage.SLCFactory")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 private constant SLC_FACTORY_STORAGE_LOCATION =
+        0x2a4c5f206148f75b3c203bb4f62027a088ca55bbc9fba0fb4e0029fabdf99000;
+
+    string private constant DEFAULT_GOVERNANCE_PARAM_NAME = "slc.governance.defaultGovernance";
+
+    function _getSLCFactoryStorage() private pure returns (SLCFactoryStorage storage $) {
+        /* solhint-disable-next-line no-inline-assembly */
+        assembly ("memory-safe") {
+            $.slot := SLC_FACTORY_STORAGE_LOCATION
+        }
+    }
+
+    event SLCDeployed(address indexed slc, address indexed governance, address indexed deployer);
+
+    error DefaultGovernanceNotSet(address parametersRegistry);
+
+    function __SLCFactory_init(
+        address initialOwner_,
+        address parametersRegistry_,
+        address slcImplementation_
+    ) external initializer {
+        __Ownable_init(initialOwner_);
+
+        SLCFactoryStorage storage $ = _getSLCFactoryStorage();
+
+        $.parametersRegistry = IQParameters(parametersRegistry_);
+        $.slcCoreImplementation = slcImplementation_;
+    }
+
+    function deploySLC(string calldata legalDocumentLink_) external virtual returns (address) {
+        SLCFactoryStorage storage $ = _getSLCFactoryStorage();
+
+        address defaultGovernance_ = $.parametersRegistry.getAddr(DEFAULT_GOVERNANCE_PARAM_NAME);
+        require(
+            defaultGovernance_ != address(0),
+            DefaultGovernanceNotSet(address($.parametersRegistry))
+        );
+
+        return _deploySLC(defaultGovernance_, legalDocumentLink_);
+    }
+
+    function deploySLCWithGovernance(
+        address governance_,
+        string calldata legalDocumentLink_
+    ) external virtual returns (address) {
+        return _deploySLC(governance_, legalDocumentLink_);
+    }
+
+    function _deploySLC(
+        address governance_,
+        string calldata legalDocumentLink_
+    ) internal returns (address) {
+        SLCFactoryStorage storage $ = _getSLCFactoryStorage();
+
+        uint256 nonce_ = _useNonce(msg.sender);
+
+        SLCCore slcCore_ = SLCCore(_deploy2($.slcCoreImplementation, getSalt(msg.sender, nonce_)));
+
+        slcCore_.__SLCCore_init(msg.sender, governance_, legalDocumentLink_, new bytes(0));
+
+        $.deployedSLCs.add(address(slcCore_));
+
+        emit SLCDeployed(address(slcCore_), governance_, msg.sender);
+
+        return address(slcCore_);
+    }
+
+    function nonces(address owner_) public view virtual returns (uint256) {
+        return _getSLCFactoryStorage().nonces[owner_];
+    }
+
+    function _useNonce(address owner_) internal virtual returns (uint256) {
+        SLCFactoryStorage storage $ = _getSLCFactoryStorage();
+        uint256 current_ = $.nonces[owner_];
+        $.nonces[owner_] = current_ + 1;
+        return current_;
+    }
+
+    function setSLCCoreImplementation(address newImplementation_) external virtual onlyOwner {
+        _getSLCFactoryStorage().slcCoreImplementation = newImplementation_;
+    }
+
+    function predictSLCAddress(
+        address slcDeployer_,
+        uint256 nonce_
+    ) external view virtual returns (address) {
+        return
+            _predictAddress(_getSLCFactoryStorage().slcCoreImplementation, slcDeployer_, nonce_);
+    }
+
+    function getSLCCoreImplementation() external view virtual returns (address) {
+        return _getSLCFactoryStorage().slcCoreImplementation;
+    }
+
+    function getSLCFactoryStorage() external view virtual returns (SLCFactoryStorageData memory) {
+        SLCFactoryStorage storage $ = _getSLCFactoryStorage();
+
+        return
+            SLCFactoryStorageData({
+                parametersRegistry: address($.parametersRegistry),
+                slcCoreImplementation: $.slcCoreImplementation
+            });
+    }
+
+    function getDeployedSLCs(
+        uint256 offset_,
+        uint256 limit_
+    ) external view virtual returns (address[] memory) {
+        EnumerableSet.AddressSet storage deployedSLCs_ = _getSLCFactoryStorage().deployedSLCs;
+        uint256 length_ = deployedSLCs_.length();
+
+        if (offset_ >= length_) {
+            return new address[](0);
+        }
+
+        uint256 to_ = offset_ + limit_;
+        if (to_ > length_) {
+            to_ = length_;
+        }
+
+        address[] memory result_ = new address[](to_ - offset_);
+        for (uint256 i = 0; i < result_.length; ++i) {
+            result_[i] = deployedSLCs_.at(offset_ + i);
+        }
+
+        return result_;
+    }
+
+    function getSalt(address slcDeployer_, uint256 nonce_) public pure virtual returns (bytes32) {
+        return keccak256(abi.encodePacked(slcDeployer_, nonce_));
+    }
+
+    function isSLCCore(address toCheck_) public view virtual returns (bool) {
+        return _getSLCFactoryStorage().deployedSLCs.contains(toCheck_);
+    }
+
+    function _deploy2(address implementation_, bytes32 salt_) internal returns (address payable) {
+        return payable(address(new ERC1967Proxy{salt: salt_}(implementation_, new bytes(0))));
+    }
+
+    function _predictAddress(
+        address implementation_,
+        address slcDeployer_,
+        uint256 nonce_
+    ) internal view virtual returns (address) {
+        bytes32 bytecodeHash = keccak256(
+            abi.encodePacked(
+                type(ERC1967Proxy).creationCode,
+                abi.encode(implementation_, new bytes(0))
+            )
+        );
+
+        return Create2.computeAddress(getSalt(slcDeployer_, nonce_), bytecodeHash);
+    }
+
+    /**
+     * @inheritdoc ERC165
+     */
+    function supportsInterface(
+        bytes4 interfaceId_
+    ) public view override(IERC165, ERC165) returns (bool) {
+        return
+            interfaceId_ == type(ISLCCoreFactory).interfaceId ||
+            super.supportsInterface(interfaceId_);
+    }
+
+    // solhint-disable-next-line no-empty-blocks
+    function _authorizeUpgrade(address) internal override onlyOwner {}
+
+    function implementation() external view returns (address) {
+        return ERC1967Utils.getImplementation();
+    }
+}

package/token/Token.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.21;
+
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+contract Token is ERC20, Ownable {
+    constructor(
+        string memory name_,
+        string memory symbol_
+    ) ERC20(name_, symbol_) Ownable(msg.sender) {}
+
+    function mint(address to_, uint256 amount_) public onlyOwner {
+        _mint(to_, amount_);
+    }
+
+    function burn(address to_, uint256 amount_) public onlyOwner {
+        _burn(to_, amount_);
+    }
+}

package/utils/Globals.sol

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+string constant TREASURY_ADDRESS_PARAM_NAME = "slc.general.treasuryAddress";
+string constant DAOSLC_PARAM_NAME = "slc.general.daoSLC";
+
+uint256 constant MAX_BASIS_POINTS = 100_00;