@diamondslab/diamonds-hardhat-foundry 1.0.0

package/contracts/DiamondFuzzBase.sol

@@ -0,0 +1,128 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "forge-std/Test.sol";
+import "forge-std/console.sol";
+import "./DiamondForgeHelpers.sol";
+
+/**
+ * @title DiamondFuzzBase
+ * @notice Base contract for Diamond fuzz testing with Forge
+ * @dev Provides setup methods and utilities for fuzz testing Diamond contracts
+ */
+abstract contract DiamondFuzzBase is Test {
+    using DiamondForgeHelpers for address;
+
+    // Diamond contract address (set by child contracts)
+    address public diamond;
+
+    // Facet addresses (set by child contracts)
+    mapping(string => address) public facets;
+
+    // Test accounts
+    address public deployer;
+    address public user1;
+    address public user2;
+    address public user3;
+
+    /**
+     * @notice Setup function called before each test
+     * @dev Override this in child contracts to set up Diamond and facets
+     */
+    function setUp() public virtual {
+        // Set up test accounts
+        deployer = address(this);
+        user1 = makeAddr("user1");
+        user2 = makeAddr("user2");
+        user3 = makeAddr("user3");
+
+        // Fund test accounts
+        vm.deal(user1, 100 ether);
+        vm.deal(user2, 100 ether);
+        vm.deal(user3, 100 ether);
+
+        // Child contracts should override and call setDiamondAddress()
+    }
+
+    /**
+     * @notice Set the Diamond contract address
+     * @param _diamond Address of the deployed Diamond
+     */
+    function setDiamondAddress(address _diamond) internal {
+        require(_diamond != address(0), "Diamond address cannot be zero");
+        diamond = _diamond;
+        DiamondForgeHelpers.assertValidDiamond(_diamond);
+    }
+
+    /**
+     * @notice Register a facet address
+     * @param name Name of the facet
+     * @param facetAddress Address of the facet
+     */
+    function registerFacet(string memory name, address facetAddress) internal {
+        require(facetAddress != address(0), "Facet address cannot be zero");
+        facets[name] = facetAddress;
+        DiamondForgeHelpers.assertValidFacet(facetAddress, name);
+    }
+
+    /**
+     * @notice Get a facet address by name
+     * @param name Name of the facet
+     * @return Address of the facet
+     */
+    function getFacet(string memory name) internal view returns (address) {
+        address facetAddress = facets[name];
+        require(facetAddress != address(0), string(abi.encodePacked("Facet not found: ", name)));
+        return facetAddress;
+    }
+
+    /**
+     * @notice Assume valid Ethereum address for fuzzing
+     * @param addr Address to validate
+     */
+    function assumeValidAddress(address addr) internal pure {
+        vm.assume(addr != address(0));
+        vm.assume(addr != address(0xdead));
+        vm.assume(uint160(addr) > 0xFF); // Avoid precompiles
+    }
+
+    /**
+     * @notice Assume valid amount for fuzzing (not zero, not unreasonably large)
+     * @param amount Amount to validate
+     */
+    function assumeValidAmount(uint256 amount) internal pure {
+        vm.assume(amount > 0);
+        vm.assume(amount < type(uint128).max); // Reasonable upper bound
+    }
+
+    /**
+     * @notice Bound a fuzzed value to a specific range
+     * @param value The fuzzed value
+     * @param min Minimum value (inclusive)
+     * @param max Maximum value (inclusive)
+     * @return Bounded value
+     */
+    function boundValue(uint256 value, uint256 min, uint256 max) internal pure returns (uint256) {
+        return bound(value, min, max);
+    }
+
+    /**
+     * @notice Log test context for debugging
+     * @param testName Name of the test
+     */
+    function logTestContext(string memory testName) internal view {
+        console.log("=== Test:", testName, "===");
+        console.log("Diamond:", diamond);
+        console.log("Deployer:", deployer);
+        console.log("Block number:", block.number);
+        console.log("Block timestamp:", block.timestamp);
+    }
+
+    /**
+     * @notice Expect a revert with specific error message
+     * @param errorMessage Expected error message
+     */
+    function expectRevertWithMessage(string memory errorMessage) internal {
+        vm.expectRevert(bytes(errorMessage));
+    }
+}

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@diamondslab/diamonds-hardhat-foundry",
+  "version": "1.0.0",
+  "description": "Hardhat plugin that integrates Foundry testing with Diamond proxy contracts, providing deployment helpers and fuzzing support",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/diamondslab/diamonds-hardhat-foundry",
+    "directory": "packages/diamonds-hardhat-foundry"
+  },
+  "homepage": "https://github.com/diamondslab/diamonds-hardhat-foundry",
+  "author": "Am0rfu5",
+  "license": "MIT",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "keywords": [
+    "ethereum",
+    "smart-contracts",
+    "hardhat",
+    "hardhat-plugin",
+    "foundry",
+    "forge",
+    "diamondslab",
+    "diamonds",
+    "diamond",
+    "solidity",
+    "erc-2535",
+    "fuzzing",
+    "testing",
+    "diamond-proxy"
+  ],
+  "scripts": {
+    "lint": "yarn prettier --check && yarn eslint",
+    "lint:fix": "yarn prettier --write && yarn eslint --fix",
+    "eslint": "eslint 'src/**/*.ts'",
+    "prettier": "prettier \"**/*.{js,md,json}\"",
+    "pretest": "cd ../.. && yarn build",
+    "test": "mocha --recursive \"test/**/*.ts\" --exit",
+    "build": "tsc --build .",
+    "prepublishOnly": "yarn build",
+    "clean": "rimraf dist"
+  },
+  "files": [
+    "dist/src/",
+    "src/",
+    "contracts/",
+    "LICENSE",
+    "README.md"
+  ],
+  "devDependencies": {
+    "@types/chai": "^4.2.0",
+    "@types/debug": "^4.1.12",
+    "@types/mocha": ">=9.1.0",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "5.61.0",
+    "@typescript-eslint/parser": "5.61.0",
+    "chai": "^4.2.0",
+    "eslint": "^8.44.0",
+    "eslint-config-prettier": "8.3.0",
+    "eslint-plugin-import": "2.27.5",
+    "eslint-plugin-mocha": "10.4.1",
+    "eslint-plugin-prettier": "3.4.0",
+    "hardhat": "^2.26.0",
+    "mocha": "^10.0.0",
+    "prettier": "2.4.1",
+    "rimraf": "^3.0.2",
+    "ts-node": "^10.8.0",
+    "typescript": "~5.0.0"
+  },
+  "peerDependencies": {
+    "@diamondslab/diamonds": "^1.2.1",
+    "@diamondslab/hardhat-diamonds": "^1.1.9",
+    "hardhat": "^2.26.0"
+  },
+  "dependencies": {
+    "picocolors": "^1.1.0"
+  },
+  "packageManager": "yarn@4.10.3"
+}

package/src/foundry.ts

@@ -0,0 +1,134 @@
+import { exec as execCallback, execSync } from "child_process";
+import { NomicLabsHardhatPluginError } from "hardhat/internal/core/errors";
+import picocolors from "picocolors";
+import { promisify } from "util";
+
+const exec = promisify(execCallback);
+
+type Remappings = Record<string, string>;
+
+let cachedRemappings: Promise<Remappings> | undefined;
+
+export class HardhatFoundryError extends NomicLabsHardhatPluginError {
+  constructor(message: string, parent?: Error) {
+    super("diamonds-hardhat-foundry", message, parent);
+  }
+}
+
+class ForgeInstallError extends HardhatFoundryError {
+  constructor(dependency: string, parent: Error) {
+    super(
+      `Couldn't install '${dependency}', please install it manually.
+
+${parent.message}
+`,
+      parent
+    );
+  }
+}
+
+export function getForgeConfig() {
+  return JSON.parse(runCmdSync("forge config --json"));
+}
+
+export function parseRemappings(remappingsTxt: string): Remappings {
+  const remappings: Remappings = {};
+  const remappingLines = remappingsTxt.split(/\r\n|\r|\n/);
+  for (const remappingLine of remappingLines) {
+    if (remappingLine.trim() === "") {
+      continue;
+    }
+
+    if (remappingLine.includes(":")) {
+      throw new HardhatFoundryError(
+        `Invalid remapping '${remappingLine}', remapping contexts are not allowed`
+      );
+    }
+
+    if (!remappingLine.includes("=")) {
+      throw new HardhatFoundryError(
+        `Invalid remapping '${remappingLine}', remappings without a target are not allowed`
+      );
+    }
+
+    const fromTo = remappingLine.split("=");
+
+    // if the remapping already exists, we ignore it because the first one wins
+    if (remappings[fromTo[0]] !== undefined) {
+      continue;
+    }
+
+    remappings[fromTo[0]] = fromTo[1];
+  }
+
+  return remappings;
+}
+
+export async function getRemappings() {
+  // Get remappings only once
+  if (cachedRemappings === undefined) {
+    cachedRemappings = runCmd("forge remappings").then(parseRemappings);
+  }
+
+  return cachedRemappings;
+}
+
+export async function installDependency(dependency: string) {
+  // Check if --no-commit flag is supported. Best way is checking the help text
+  const helpText = await runCmd("forge install --help");
+  const useNoCommitFlag = helpText.includes("--no-commit");
+
+  const cmd = `forge install ${
+    useNoCommitFlag ? "--no-commit" : ""
+  } ${dependency}`;
+
+  console.log(`Running '${picocolors.blue(cmd)}'`);
+
+  try {
+    await exec(cmd);
+  } catch (error: any) {
+    throw new ForgeInstallError(dependency, error);
+  }
+}
+
+function runCmdSync(cmd: string): string {
+  try {
+    return execSync(cmd, { stdio: "pipe" }).toString();
+  } catch (error: any) {
+    const pluginError = buildForgeExecutionError(
+      error.status,
+      error.stderr.toString()
+    );
+
+    throw pluginError;
+  }
+}
+
+async function runCmd(cmd: string): Promise<string> {
+  try {
+    const { stdout } = await exec(cmd);
+    return stdout;
+  } catch (error: any) {
+    throw buildForgeExecutionError(error.code, error.message);
+  }
+}
+
+function buildForgeExecutionError(
+  exitCode: number | undefined,
+  message: string
+) {
+  switch (exitCode) {
+    case 127:
+      return new HardhatFoundryError(
+        "Couldn't run `forge`. Please check that your foundry installation is correct."
+      );
+    case 134:
+      return new HardhatFoundryError(
+        "Running `forge` failed. Please check that your foundry.toml file is correct."
+      );
+    default:
+      return new HardhatFoundryError(
+        `Unexpected error while running \`forge\`: ${message}`
+      );
+  }
+}

package/src/framework/DeploymentManager.ts

@@ -0,0 +1,210 @@
+import { Diamond } from "@diamondslab/diamonds";
+import { existsSync } from "fs";
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+import { join } from "path";
+import { Logger } from "../utils/logger";
+
+// Type for LocalDiamondDeployer (avoiding import issues)
+type LocalDiamondDeployerConfig = {
+  diamondName: string;
+  networkName: string;
+  provider: any;
+  chainId: number;
+  writeDeployedDiamondData: boolean;
+};
+
+/**
+ * DeploymentManager - Manages Diamond deployment lifecycle for Forge testing
+ * 
+ * Note: This class dynamically requires LocalDiamondDeployer from the workspace
+ * to avoid module resolution issues in the published package.
+ */
+export class DeploymentManager {
+  constructor(private hre: HardhatRuntimeEnvironment) {}
+
+  /**
+   * Get LocalDiamondDeployer class
+   * @private
+   */
+  private async getDeployerClass(): Promise<any> {
+    // LocalDiamondDeployer is in the workspace scripts, not exported from the module
+    // This will need to be available in user projects
+    const localDeployerPath = join(
+      this.hre.config.paths.root,
+      "scripts/setup/LocalDiamondDeployer"
+    );
+    
+    try {
+      const deployer = await import(localDeployerPath);
+      return deployer.LocalDiamondDeployer;
+    } catch {
+      throw new Error(
+        "LocalDiamondDeployer not found. Make sure your project has scripts/setup/LocalDiamondDeployer.ts"
+      );
+    }
+  }
+
+  /**
+   * Deploy a Diamond using LocalDiamondDeployer
+   * @param diamondName - Name of the Diamond to deploy
+   * @param networkName - Target network (hardhat, localhost, anvil)
+   * @param force - Force redeployment even if exists
+   */
+  async deploy(
+    diamondName: string = "ExampleDiamond",
+    networkName: string = "hardhat",
+    force: boolean = false
+  ): Promise<Diamond> {
+    Logger.section(`Deploying ${diamondName} to ${networkName}`);
+
+    // Get provider and network info
+    const provider = this.hre.ethers.provider;
+    const network = await provider.getNetwork();
+    const chainId = Number(network.chainId);
+
+    // Check if deployment exists and handle force flag
+    if (!force && this.hasDeploymentRecord(diamondName, networkName, chainId)) {
+      Logger.info("Deployment record exists, using existing deployment");
+      Logger.info("Use --force to redeploy");
+      
+      const LocalDiamondDeployer = await this.getDeployerClass();
+      const deployer = await LocalDiamondDeployer.getInstance({
+        diamondName,
+        networkName,
+        provider,
+        chainId,
+        writeDeployedDiamondData: true,
+      } as LocalDiamondDeployerConfig);
+      
+      return await deployer.getDiamond();
+    }
+
+    Logger.step("Initializing LocalDiamondDeployer...");
+    
+    const LocalDiamondDeployer = await this.getDeployerClass();
+    
+    const deployer = await LocalDiamondDeployer.getInstance({
+      diamondName,
+      networkName,
+      provider,
+      chainId,
+      writeDeployedDiamondData: true,
+    } as LocalDiamondDeployerConfig);
+
+    await deployer.setVerbose(false); // Reduce noise, use our logger instead
+
+    Logger.step("Deploying Diamond contract...");
+    const diamond = await deployer.getDiamondDeployed();
+    
+    const deployedData = diamond.getDeployedDiamondData();
+    
+    Logger.success(`Diamond deployed at: ${deployedData.DiamondAddress}`);
+    Logger.info(`Deployer: ${deployedData.DeployerAddress}`);
+    Logger.info(`Facets deployed: ${Object.keys(deployedData.DeployedFacets || {}).length}`);
+
+    return diamond;
+  }
+
+  /**
+   * Get existing deployment record
+   * @param diamondName - Name of the Diamond
+   * @param networkName - Network name
+   * @param chainId - Chain ID
+   */
+  async getDeployment(
+    diamondName: string = "ExampleDiamond",
+    networkName: string = "hardhat",
+    chainId?: number
+  ): Promise<Diamond | null> {
+    try {
+      const provider = this.hre.ethers.provider;
+      const network = await provider.getNetwork();
+      const actualChainId = chainId ?? Number(network.chainId);
+
+      if (!this.hasDeploymentRecord(diamondName, networkName, actualChainId)) {
+        Logger.warn("No deployment record found");
+        return null;
+      }
+
+      const LocalDiamondDeployer = await this.getDeployerClass();
+      const deployer = await LocalDiamondDeployer.getInstance({
+        diamondName,
+        networkName,
+        provider,
+        chainId: actualChainId,
+        writeDeployedDiamondData: false,
+      } as LocalDiamondDeployerConfig);
+
+      return await deployer.getDiamond();
+    } catch (error) {
+      Logger.error(`Failed to get deployment: ${error}`);
+      return null;
+    }
+  }
+
+  /**
+   * Ensure deployment exists, deploy if needed
+   * @param diamondName - Name of the Diamond
+   * @param networkName - Network name
+   * @param force - Force redeployment
+   */
+  async ensureDeployment(
+    diamondName: string = "ExampleDiamond",
+    networkName: string = "hardhat",
+    force: boolean = false
+  ): Promise<Diamond> {
+    const provider = this.hre.ethers.provider;
+    const network = await provider.getNetwork();
+    const chainId = Number(network.chainId);
+
+    // Check if deployment exists
+    const existing = await this.getDeployment(diamondName, networkName, chainId);
+    
+    if (existing && !force) {
+      Logger.info("Using existing deployment");
+      return existing;
+    }
+
+    // Deploy if not exists or force is true
+    return await this.deploy(diamondName, networkName, force);
+  }
+
+  /**
+   * Check if deployment record exists
+   * @private
+   */
+  private hasDeploymentRecord(
+    diamondName: string,
+    networkName: string,
+    chainId: number
+  ): boolean {
+    const deploymentFileName = `${diamondName.toLowerCase()}-${networkName.toLowerCase()}-${chainId}.json`;
+    const deploymentPath = join(
+      this.hre.config.paths.root,
+      "diamonds",
+      diamondName,
+      "deployments",
+      deploymentFileName
+    );
+
+    return existsSync(deploymentPath);
+  }
+
+  /**
+   * Get deployment file path
+   */
+  getDeploymentPath(
+    diamondName: string,
+    networkName: string,
+    chainId: number
+  ): string {
+    const deploymentFileName = `${diamondName.toLowerCase()}-${networkName.toLowerCase()}-${chainId}.json`;
+    return join(
+      this.hre.config.paths.root,
+      "diamonds",
+      diamondName,
+      "deployments",
+      deploymentFileName
+    );
+  }
+}