Improve Type Safety & DevKit Testing

.github/workflows/ci.yml

@@ -1,6 +1,6 @@
 name: Continuous Integration
 
 on:
   pull_request:
     types:
       - opened
@@ -42,6 +42,23 @@
         run: |
           forge test
 
+  install-with-template-test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Install Foundry
+        uses: foundry-rs/foundry-toolchain@v1
+        with:
+          version: nightly
+      - name: Run forge install
+        run: |
+          mkdir /tmp/install-with-template-test
+          cd /tmp/install-with-template-test
+          forge init mc-example-project -t metacontract/template
+          forge test
+
   # slither:
   #   runs-on: ubuntu-latest
   #   steps:

.gitmodules

@@ -4,6 +4,3 @@
 [submodule "lib/ucs-contracts"]
 	path = lib/ucs-contracts
 	url = https://github.com/ecdysisxyz/ucs-contracts
-[submodule "lib/openzeppelin-contracts"]
-	path = lib/openzeppelin-contracts
-	url = https://github.com/openzeppelin/openzeppelin-contracts

devkit/MCDevKit.sol

@@ -2,25 +2,29 @@
 pragma solidity ^0.8.24;
 
 // Registries
-import {FunctionRegistry} from "devkit/ucs/functions/FunctionRegistry.sol";
-import {DictionaryRegistry} from "devkit/ucs/dictionary/DictionaryRegistry.sol";
-import {ProxyRegistry} from "devkit/ucs/proxy/ProxyRegistry.sol";
+import {StdRegistry} from "devkit/registry/StdRegistry.sol";
+import {FunctionRegistry} from "devkit/registry/FunctionRegistry.sol";
+import {BundleRegistry} from "devkit/registry/BundleRegistry.sol";
+import {DictionaryRegistry} from "devkit/registry/DictionaryRegistry.sol";
+import {ProxyRegistry} from "devkit/registry/ProxyRegistry.sol";
 
 // Global Methods
-import {MCSetupLib} from "devkit/global/MCSetupLib.sol";
-import {MCBundleLib} from "devkit/global/MCBundleLib.sol";
-import {MCDeployLib} from "devkit/global/MCDeployLib.sol";
-import {MCFinderLib} from "devkit/global/MCFinderLib.sol";
-import {MCContextLib} from "devkit/global/MCContextLib.sol";
-import {MCTestLib} from "devkit/global/MCTestLib.sol";
-import {MCDebugLib} from "devkit/global/MCDebugLib.sol";
+import {MCSetupLib} from "devkit/utils/global/MCSetupLib.sol";
+import {MCBundleLib} from "devkit/utils/global/MCBundleLib.sol";
+import {MCDeployLib} from "devkit/utils/global/MCDeployLib.sol";
+import {MCFinderLib} from "devkit/utils/global/MCFinderLib.sol";
+import {MCContextLib} from "devkit/utils/global/MCContextLib.sol";
+import {MCTestLib} from "devkit/utils/global/MCTestLib.sol";
+import {MCDebugLib} from "devkit/utils/global/MCDebugLib.sol";
 
 
 /********************************
     🌟 Meta Contract DevKit
 *********************************/
 struct MCDevKit {
+    StdRegistry std;
     FunctionRegistry functions;
+    BundleRegistry bundle;
     DictionaryRegistry dictionary;
     ProxyRegistry proxy;
 }

devkit/MCScript.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.24;
 
-import {Config} from "devkit/config/Config.sol";
+import {System} from "devkit/system/System.sol";
 
 // 💬 ABOUT
 // Meta Contract's default Script based on Forge Std Script
@@ -12,16 +12,16 @@ import {MCScriptBase} from "./MCBase.sol";
 // ⭐️ MC SCRIPT
 abstract contract MCScript is MCScriptBase {
     constructor() {
-        Config().load();
-        if (Config().DEBUG_MODE) mc.startDebug();
-        if (Config().SETUP_STD_FUNCS) mc.setupStdFunctions();
+        mc.loadConfig();
+        mc.startDebug();
+        if (System.Config().SETUP_STD_FUNCS) mc.setupStdFunctions();
     }
 }
 
 // ⭐️ MC SCRIPT without Setup
 abstract contract MCScriptWithoutSetup is MCScriptBase {
     constructor() {
-        Config().load();
-        if (Config().DEBUG_MODE) mc.startDebug();
+        mc.loadConfig();
+        mc.startDebug();
     }
 }

devkit/MCTest.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.24;
 
-import {Config} from "devkit/config/Config.sol";
-import {DecodeErrorString} from "./error/DecodeErrorString.sol";
+import {System} from "devkit/system/System.sol";
+import {DecodeErrorString} from "devkit/system/message/DecodeErrorString.sol";
 
 // 💬 ABOUT
 // Meta Contract's default Test based on Forge Std Test
@@ -13,9 +13,9 @@ import {MCTestBase} from "./MCBase.sol";
 // ⭐️ MC TEST
 abstract contract MCTest is MCTestBase {
     constructor() {
-        Config().load();
-        if (Config().DEBUG_MODE) mc.startDebug();
-        if (Config().SETUP_STD_FUNCS) mc.setupStdFunctions();
+        System.Config().load();
+        if (System.Config().DEBUG_MODE) mc.startDebug();
+        if (System.Config().SETUP_STD_FUNCS) mc.setupStdFunctions();
     }
 }
 
@@ -47,7 +47,7 @@ abstract contract MCStateFuzzingTest is MCTestBase {
 // 🌟 MC TEST for DevKit
 abstract contract MCDevKitTest is MCTestBase {
     constructor() {
-        Config().load();
+        System.Config().load();
         mc.stopLog();
     }
 }

devkit/core/Bundle.sol

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+/**---------------------
+    Support Methods
+-----------------------*/
+import {ProcessLib} from "devkit/system/debug/Process.sol";
+    using ProcessLib for Bundle global;
+import {Inspector} from "devkit/types/Inspector.sol";
+    using Inspector for Bundle global;
+import {TypeGuard, TypeStatus} from "devkit/types/TypeGuard.sol";
+    using TypeGuard for Bundle global;
+// Validation
+import {Validate} from "devkit/system/validate/Validate.sol";
+
+// Core Type
+import {Function} from "devkit/core/Function.sol";
+
+
+/**================
+    🗂️ Bundle
+==================*/
+using BundleLib for Bundle global;
+struct Bundle {
+    string name;
+    Function[] functions;
+    address facade;
+    TypeStatus status;
+}
+library BundleLib {
+
+    /**--------------------
+        📛 Assign Name
+    ----------------------*/
+    function assignName(Bundle storage bundle, string memory name) internal returns(Bundle storage) {
+        uint pid = bundle.startProcess("assignName");
+        Validate.MUST_BundleNotLocked(bundle);
+        Validate.MUST_NotEmptyName(name);
+        bundle.name = name;
+        return bundle.building().finishProcess(pid);
+    }
+
+    /**-------------------------
+        🧩 Push Function(s)
+    ---------------------------*/
+    function pushFunction(Bundle storage bundle, Function storage func) internal returns(Bundle storage) {
+        uint pid = bundle.startProcess("pushFunction");
+        Validate.MUST_BundleNotLocked(bundle);
+        Validate.MUST_completed(func);
+        Validate.MUST_notHave(bundle, func);
+        bundle.functions.push(func);
+        return bundle.building().finishProcess(pid);
+    }
+    function pushFunctions(Bundle storage bundle, Function[] storage functions) internal returns(Bundle storage) {
+        uint pid = bundle.startProcess("pushFunctions");
+        for (uint i; i < functions.length; ++i) {
+            bundle.pushFunction(functions[i]);
+        }
+        return bundle.building().finishProcess(pid);
+    }
+
+    /**----------------------
+        🪟 Assign Facade
+    ------------------------*/
+    function assignFacade(Bundle storage bundle, address facade) internal returns(Bundle storage) {
+        uint pid = bundle.startProcess("assignFacade");
+        Validate.MUST_AddressIsContract(facade);
+        bundle.facade = facade;
+        return bundle.building().finishProcess(pid);
+    }
+
+}

devkit/core/Dictionary.sol

@@ -0,0 +1,154 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+/**---------------------
+    Support Methods
+-----------------------*/
+import {ProcessLib} from "devkit/system/debug/Process.sol";
+    using ProcessLib for Dictionary global;
+import {Params} from "devkit/system/debug/Params.sol";
+import {Inspector} from "devkit/types/Inspector.sol";
+    using Inspector for Dictionary global;
+    using Inspector for bytes4;
+import {ForgeHelper} from "devkit/utils/ForgeHelper.sol";
+// Validation
+import {Validate} from "devkit/system/validate/Validate.sol";
+import {TypeGuard, TypeStatus} from "devkit/types/TypeGuard.sol";
+    using TypeGuard for Dictionary global;
+
+// Mock
+import {DictionaryMock} from "devkit/mocks/DictionaryMock.sol";
+// External Libs
+import {IDictionary} from "@ucs.mc/dictionary/IDictionary.sol";
+import {Dictionary as UCSDictionary} from "@ucs.mc/dictionary/Dictionary.sol";
+
+// Core Types
+import {Function} from "devkit/core/Function.sol";
+import {Bundle} from "devkit/core/Bundle.sol";
+
+
+/**====================
+    📚 Dictionary
+======================*/
+using DictionaryLib for Dictionary global;
+struct Dictionary {
+    address addr;
+    DictionaryKind kind;
+    TypeStatus status;
+}
+library DictionaryLib {
+    /**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        🚀 Deploy Dictionary
+        🔂 Duplicate Dictionary
+        🧩 Set Function or Bundle
+        🪟 Upgrade Facade
+        🤖 Create Dictionary Mock
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
+
+    /**-------------------------
+        🚀 Deploy Dictionary
+    ---------------------------*/
+    function deploy(address owner) internal returns(Dictionary memory) {
+        uint pid = ProcessLib.startDictionaryLibProcess("deploy");
+        Validate.MUST_AddressIsNotZero(owner);
+        /// @dev Until Etherscan supports UCS, we are deploying contracts with additional features for Etherscan compatibility by default.
+        return Dictionary({
+            addr: address(new UCSDictionary(owner)),
+            kind: DictionaryKind.Verifiable,
+            status: TypeStatus.Building
+        }).finishProcess(pid);
+    }
+
+    /**----------------------------
+        🔂 Duplicate Dictionary
+    ------------------------------*/
+    function duplicate(Dictionary memory toDictionary, Dictionary memory fromDictionary) internal returns(Dictionary memory) {
+        uint pid = ProcessLib.startDictionaryLibProcess("duplicate");
+        Validate.MUST_haveContract(toDictionary);
+        Validate.MUST_haveContract(fromDictionary);
+
+        address toAddr = toDictionary.addr;
+        address fromAddr = fromDictionary.addr;
+
+        bytes4[] memory _selectors = IDictionary(fromAddr).supportsInterfaces();
+        for (uint i; i < _selectors.length; ++i) {
+            bytes4 _selector = _selectors[i];
+            if (_selector.isEmpty()) continue;
+            toDictionary.set(_selector, IDictionary(fromAddr).getImplementation(_selector));
+        }
+
+        return toDictionary.finishProcess(pid);
+    }
+    function duplicate(Dictionary memory fromDictionary) internal returns(Dictionary memory) {
+        return duplicate(deploy(ForgeHelper.msgSender()), fromDictionary);
+    }
+
+    /**-----------------------------
+        🧩 Set Function or Bundle
+    -------------------------------*/
+    function set(Dictionary memory dictionary, bytes4 selector, address implementation) internal returns(Dictionary memory) {
+        uint pid = ProcessLib.startDictionaryLibProcess("set", Params.append(selector, implementation));
+        Validate.MUST_haveContract(dictionary);
+        Validate.MUST_Bytes4NotEmpty(selector);
+        Validate.MUST_AddressIsContract(implementation);
+        IDictionary(dictionary.addr).setImplementation({
+            functionSelector: selector,
+            implementation: implementation
+        });
+        return dictionary.finishProcess(pid);
+    }
+    function set(Dictionary memory dictionary, Function memory func) internal returns(Dictionary memory) {
+        uint pid = ProcessLib.startDictionaryLibProcess("set", Params.append(func.name));
+        return set(dictionary, func.selector, func.implementation).finishProcess(pid);
+    }
+    function set(Dictionary memory dictionary, Bundle storage bundle) internal returns(Dictionary memory) {
+        uint pid = ProcessLib.startDictionaryLibProcess("set", Params.append(bundle.name));
+
+        Function[] memory functions = bundle.functions;
+
+        for (uint i; i < functions.length; ++i) {
+            set(dictionary, functions[i]);
+        }
+
+        // TODO Generate Facade
+        // if (dictionary.isVerifiable()) {
+        //     dictionary.upgradeFacade(bundle.facade);
+        // }
+
+        return dictionary.finishProcess(pid);
+    }
+
+    /**----------------------
+        🪟 Upgrade Facade
+    ------------------------*/
+    function upgradeFacade(Dictionary memory dictionary, address newFacade) internal returns(Dictionary memory) {
+        uint pid = ProcessLib.startDictionaryLibProcess("upgradeFacade");
+        Validate.MUST_AddressIsContract(newFacade);
+        Validate.MUST_Verifiable(dictionary);
+        IDictionary(dictionary.addr).upgradeFacade(newFacade);
+        return dictionary.finishProcess(pid);
+    }
+
+    /**------------------------------
+        🤖 Create Dictionary Mock
+    --------------------------------*/
+    function createMock(address owner, Function[] memory functions) internal returns(Dictionary memory) {
+        uint pid = ProcessLib.startDictionaryLibProcess("createMock");
+        return Dictionary({
+            addr: address(new DictionaryMock(owner, functions)),
+            kind: DictionaryKind.Mock,
+            status: TypeStatus.Building
+        }).finishProcess(pid);
+    }
+
+}
+
+
+/**--------------------
+    Dictionary Kind
+----------------------*/
+enum DictionaryKind {
+    undefined,
+    Verifiable,
+    Mock
+}
+using Inspector for DictionaryKind global;