deploy script: tinkering with facet deploy implementation

Author: quirps

.gitignore

@@ -12,3 +12,6 @@ docs/
 
 # Dotenv file
 .env
+
+#js
+node_modules/

package-lock.json

@@ -0,0 +1,19 @@
+{
+  "name": "my-foundry-project",
+  "version": "1.0.0",
+  "description": "**Foundry is a blazing fast, portable and modular toolkit for Ethereum application development written in Rust.**",
+  "main": "index.js",
+  "directories": {
+    "lib": "lib",
+    "test": "test"
+  },
+  "type":"module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "ethers": "^6.15.0"
+  }
+}

package.json

@@ -4,18 +4,28 @@ pragma solidity ^0.8.20;
 import {Script} from "forge-std/Script.sol";
 import {console2} from "forge-std/console2.sol";
 import {IDiamondCut} from "../src/facets/Diamond/IDiamondCut.sol"; // Adjust to your imports
-import {DiamondCutFacet} from "../src/facets/Diamond/DiamondCutFacet.sol"; // Example; not used directly
 
 contract DeployDiamond is Script {
     // Configurable list: Add new facet names here (e.g., "MarketplaceFacet")
     string[] public facetNames = [
         "DiamondCutFacet",
         "DiamondLoupeFacet",
         "OwnershipFacet",
-        "ERC20Facet"
+        "ERC20Facet",
+        "ERC2771Recipient"
         // Add "MarketplaceFacet" here for auto-inclusion
     ];
 
+    // Parallel list: Subdirectories for each facet (in same order as facetNames)
+    string[] public subdirs = [
+        "Diamond",
+        "Diamond",
+        "Ownership",
+        "ERC20",
+        "ERC2771Recipient"
+        // Add corresponding subdir for new facets
+    ];
+
     function setUp() public {} // Optional setup
 
     function run() public {
@@ -30,7 +40,8 @@ contract DeployDiamond is Script {
 
         // Step 3: Deploy Diamond (adapt to your DiamondDeploy logic)
         // address diamond = address(new DiamondDeploy(facetCuts));
-        // ... (e.g., cut the diamond, transfer ownership)
+        // IDiamondCut(address(diamond)).diamondCut(facetCuts, IDiamondCut.DiamondCutFunctionType.Add, ""); // Initial cut
+        // OwnershipFacet(address(diamond)).transferOwnership(msg.sender); // Example
 
         // Optional: Persist selectors to JSON for reuse
         _persistSelectors(facetCuts);
@@ -39,51 +50,19 @@ contract DeployDiamond is Script {
     }
 
     /// @dev Builds FacetCut[] by dynamically fetching selectors and deploying facets.
+    /// Now stack-safe: Loop has minimal locals; heavy work delegated.
     function _buildFacetCuts() internal returns (IDiamondCut.FacetCut[] memory cuts) {
         uint256 numFacets = facetNames.length;
         cuts = new IDiamondCut.FacetCut[](numFacets);
 
         for (uint256 i = 0; i < numFacets; ++i) {
             string memory name = facetNames[i];
-            string memory contractId = string.concat("src/facets/", name, ".sol:", name);
-
-            // Fetch methodIdentifiers JSON
-            string[] memory inspectCmd = new string[](5);
-            inspectCmd[0] = "forge";
-            inspectCmd[1] = "inspect";
-            inspectCmd[2] = contractId;
-            inspectCmd[3] = "methodIdentifiers";
-            inspectCmd[4] = "--json";
-
-            bytes memory outputBytes = vm.ffi(inspectCmd);
-            string memory json = string(outputBytes);
-
-            // Parse all selector hex strings (e.g., ["0xa9059cbb", ...])
-            bytes memory selBytes = vm.parseJson(json, ".methodIdentifiers.[]");
-            string[] memory selStrings = abi.decode(selBytes, (string[]));
-
-            // Convert to bytes4[]
-            bytes4[] memory selectors = new bytes4[](selStrings.length);
-            for (uint256 j = 0; j < selStrings.length; ++j) {
-                selectors[j] = bytes4(vm.parseBytes32(selStrings[j])); 
-            }
-
-            // Fetch bytecode JSON for deployment
-            string[] memory bytecodeCmd = new string[](5);
-            bytecodeCmd[0] = "forge";
-            bytecodeCmd[1] = "inspect";
-            bytecodeCmd[2] = contractId;
-            bytecodeCmd[3] = "bytecode";
-            bytecodeCmd[4] = "--json";
-
-            bytes memory bytecodeOutputBytes = vm.ffi(bytecodeCmd);
-            string memory bytecodeJson = string(bytecodeOutputBytes);
+            string memory subdir = subdirs[i]; // Fetch corresponding subdir
+            string memory contractId = string.concat("src/facets/", subdir, "/", name, ".sol:", name);
 
-            // Parse bytecode hex string (e.g., "0x6080604052...")
-            string memory bytecodeStr = abi.decode(vm.parseJson(bytecodeJson, ".bytecode"), (string));
-            bytes memory bytecode = vm.parseBytes(bytecodeStr); // Handles full hex
-
-            // Deploy facet
+            // Delegate to sub-functions to avoid stack bloat
+            bytes4[] memory selectors = _getSelectors(contractId);
+            bytes memory bytecode = _getBytecode(contractId);
             address facetAddr = _deployCode(bytecode);
 
             // Build cut (Add action; adjust if Replace/Remove needed)
@@ -97,6 +76,55 @@ contract DeployDiamond is Script {
         }
     }
 
+    /// @dev Fetches and parses method selectors via FFI.
+    function _getSelectors(string memory contractId) internal returns (bytes4[] memory selectors) {
+        string[] memory inspectCmd = new string[](5);
+        inspectCmd[0] = "forge";
+        inspectCmd[1] = "inspect";
+        inspectCmd[2] = contractId;
+        inspectCmd[3] = "methodIdentifiers";
+        inspectCmd[4] = "--json";
+
+        bytes memory outputBytes = vm.ffi(inspectCmd);
+        string memory json = string(outputBytes);
+
+        // Parse JSON: Root is { "sig": "sel", ... } → ".*" selects all values as string[] of hex selectors (no "0x")
+        bytes memory selBytes = vm.parseJson(json, ".*");
+        string[] memory selStrings = abi.decode(selBytes, (string[]));
+
+        // Edge case: No selectors (e.g., abstract contract)
+        if (selStrings.length == 0) {
+            selectors = new bytes4[](0);
+            return selectors;
+        }
+
+        selectors = new bytes4[](selStrings.length);
+        for (uint256 j = 0; j < selStrings.length; ++j) {
+            // Prepend "0x" since forge inspect outputs raw hex without prefix
+            string memory hexWithPrefix = string.concat("0x", selStrings[j]);
+            console2.log("Parsed selector hex: %s", hexWithPrefix); // Debug: Confirm prepending
+            // vm.parseBytes32 converts "0x..." hex string to bytes32; cast to bytes4 (first 4 bytes)
+            selectors[j] = bytes4(vm.parseBytes32(hexWithPrefix));
+            console2.log("Selector %d: %s", j, hexWithPrefix); // Debug: Log each selector
+        }
+    }
+
+    /// @dev Fetches bytecode via FFI.
+    function _getBytecode(string memory contractId) internal returns (bytes memory bytecode) {
+        string[] memory bytecodeCmd = new string[](5);
+        bytecodeCmd[0] = "forge";
+        bytecodeCmd[1] = "inspect";
+        bytecodeCmd[2] = contractId;
+        bytecodeCmd[3] = "bytecode";
+        bytecodeCmd[4] = "--json";
+
+        bytes memory outputBytes = vm.ffi(bytecodeCmd);
+        string memory bytecodeJson = string(outputBytes);
+
+        string memory bytecodeStr = abi.decode(vm.parseJson(bytecodeJson, ".bytecode"), (string));
+        bytecode = vm.parseBytes(bytecodeStr);
+    }
+
     /// @dev Deploys raw creation bytecode (assumes no constructor args).
     function _deployCode(bytes memory code) internal returns (address addr) {
         assembly {
@@ -112,22 +140,17 @@ contract DeployDiamond is Script {
         string memory root = vm.projectRoot();
         string memory filePath = string.concat(root, "/facet-selectors.json");
 
-        // Manual JSON build (simple; use forge-std/StdJson.sol for complex structs)
+        // Build JSON manually (simple array of objects)
         string memory jsonContent = '{"facets": [';
         for (uint256 i = 0; i < cuts.length; ++i) {
-            string memory name = facetNames[i]; // Map back via index 
+            string memory name = facetNames[i]; // Map back via index
             jsonContent = string.concat(jsonContent, '{"name":"', name, '","selectors":[');
-            for (uint256 j = 0; j < cuts[i].functionSelectors.length; ++j) {
-                // Convert bytes4 back to hex string for JSON
-                bytes memory selHex = new bytes(10); // "0x" + 8 hex chars
-                selHex[0] = bytes1(hex"30"); // '0'
-                selHex[1] = bytes1(hex"78"); // 'x'
-                // ... (assembly or loop to append hex; simplified here)
-                // Full impl: Use toHexString from forge-std/Test.sol
-                jsonContent = string.concat(jsonContent, '"0x', _toHexString(cuts[i].functionSelectors[j]), '"');
-                if (j < cuts[i].functionSelectors.length - 1) jsonContent = string.concat(jsonContent, ",");
+            bytes4[] memory selectors = cuts[i].functionSelectors;
+            for (uint256 j = 0; j < selectors.length; ++j) {
+                jsonContent = string.concat(jsonContent, '"', _toHexString(selectors[j]), '"');
+                if (j < selectors.length - 1) jsonContent = string.concat(jsonContent, ",");
             }
-            jsonContent = string.concat(jsonContent, ']}}');
+            jsonContent = string.concat(jsonContent, ']}');
             if (i < cuts.length - 1) jsonContent = string.concat(jsonContent, ",");
         }
         jsonContent = string.concat(jsonContent, ']}');
@@ -136,25 +159,22 @@ contract DeployDiamond is Script {
         console2.log("Persisted selectors to %s", filePath);
     }
 
-    // Helper: bytes4 to hex string (adapt from forge-std/Test.sol)
+    // Helper: bytes4 to hex string (e.g., "0xa9059cbb")
     function _toHexString(bytes4 value) internal pure returns (string memory) {
-        bytes memory str = new bytes(10);
-        str[0] = "0";
-        str[1] = "x";
+        bytes memory str = new bytes(10); // "0x" + 8 hex chars
+        str[0] = bytes1(uint8(48)); // '0'
+        str[1] = bytes1(uint8(120)); // 'x'
+        uint256 temp = uint256(uint32(value));
         for (uint256 i = 0; i < 4; ++i) {
-            uint8 _byte = uint8(uint32(value) >> (8 * (3 - i)));
-            str[2 + i * 2] = _toHexDigit(_byte >> 4);
-            str[3 + i * 2] = _toHexDigit(_byte & 0x0f);
+            uint8 byteVal = uint8(temp >> (8 * (3 - i)));
+            str[2 + i * 2] = _toHexDigit(uint8(byteVal >> 4));
+            str[3 + i * 2] = _toHexDigit(uint8(byteVal & 0x0f));
         }
         return string(str);
     }
 
     function _toHexDigit(uint8 digit) internal pure returns (bytes1) {
-        if (digit < 10) return bytes1(char(uint8(48 + digit)));
-        return bytes1(char(uint8(97 + digit - 10)));
-    }
-
-    function char(uint8 b) internal pure returns (bytes1) {
-        return bytes1(b);
+        uint8 c = digit < 10 ? uint8(48 + digit) : uint8(97 + digit - 10); // '0'-'9', 'a'-'f'
+        return bytes1(c);
     }
 }