@cofhe/hardhat-plugin 0.0.0-alpha-20260409113701

package/dist/index.js

@@ -0,0 +1,580 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  TASK_COFHE_MOCKS_DEPLOY: () => TASK_COFHE_MOCKS_DEPLOY,
+  TASK_COFHE_MOCKS_SET_LOG_OPS: () => TASK_COFHE_MOCKS_SET_LOG_OPS,
+  TASK_COFHE_USE_FAUCET: () => TASK_COFHE_USE_FAUCET,
+  buildHardhatPluginMocksConfig: () => buildHardhatPluginMocksConfig,
+  deployMockContractFromArtifact: () => deployMockContractFromArtifact,
+  deployMocks: () => deployMocks,
+  getFixedMockContract: () => getFixedMockContract,
+  localcofheFundAccount: () => localcofheFundAccount,
+  localcofheFundWalletIfNeeded: () => localcofheFundWalletIfNeeded,
+  mock_expectPlaintext: () => mock_expectPlaintext,
+  mock_getPlaintext: () => mock_getPlaintext,
+  mock_getPlaintextExists: () => mock_getPlaintextExists,
+  mock_setLoggingEnabled: () => mock_setLoggingEnabled,
+  mock_withLogs: () => mock_withLogs
+});
+module.exports = __toCommonJS(src_exports);
+var import_chalk3 = __toESM(require("chalk"));
+var import_viem = require("viem");
+var import_config = require("hardhat/config");
+var import_task_names = require("hardhat/builtin-tasks/task-names");
+var import_signers = require("@nomicfoundation/hardhat-ethers/signers");
+var import_sdk3 = require("@cofhe/sdk");
+var import_node = require("@cofhe/sdk/node");
+var import_adapters = require("@cofhe/sdk/adapters");
+
+// src/fund.ts
+var import_types = require("hardhat/types");
+var import_hardhat_ethers = require("@nomicfoundation/hardhat-ethers");
+async function localcofheFundAccount(hre, toAddress, amount = "10") {
+  const privateKey = process.env.FUNDER_PRIVATE_KEY ?? "0xb6b15c8cb491557369f3c7d2c287b053eb229daa9c22138887752191c9520659";
+  if (!privateKey) {
+    console.error("Error: FUNDER_PRIVATE_KEY environment variable not set");
+    return null;
+  }
+  try {
+    const wallet = new hre.ethers.Wallet(privateKey, hre.ethers.provider);
+    const balance = await hre.ethers.provider.getBalance(wallet.address);
+    console.log(`Funder wallet address: ${wallet.address}`);
+    console.log(`Funder wallet balance: ${hre.ethers.formatEther(balance)} ETH`);
+    const amountToSend = hre.ethers.parseEther(amount);
+    if (balance < amountToSend) {
+      console.error(
+        `Error: Funder wallet doesn't have enough funds. Current balance: ${hre.ethers.formatEther(balance)} ETH`
+      );
+      return null;
+    }
+    console.log(`Sending ${amount} ETH to ${toAddress}...`);
+    const tx = await wallet.sendTransaction({
+      to: toAddress,
+      value: amountToSend
+    });
+    console.log(`Transaction sent! Hash: ${tx.hash}`);
+    console.log("Waiting for confirmation...");
+    const receipt = await tx.wait();
+    console.log(`Transaction confirmed in block ${receipt?.blockNumber}`);
+    console.log(`Successfully sent ${amount} ETH to ${toAddress}`);
+    return receipt;
+  } catch (error) {
+    console.error("Error sending funds:", error);
+    return null;
+  }
+}
+async function localcofheFundWalletIfNeeded(hre, walletAddress) {
+  const walletBalance = await hre.ethers.provider.getBalance(walletAddress);
+  console.log(`Wallet balance: ${hre.ethers.formatEther(walletBalance)} ETH`);
+  if (walletBalance < hre.ethers.parseEther("1")) {
+    console.log(`Wallet balance is less than 1 ETH. Funding ${walletAddress}...`);
+    const receipt = await localcofheFundAccount(hre, walletAddress);
+    if (receipt) {
+      const newBalance = await hre.ethers.provider.getBalance(walletAddress);
+      console.log(`Wallet new balance: ${hre.ethers.formatEther(newBalance)} ETH`);
+    } else {
+      console.error(`Failed to fund ${walletAddress}`);
+    }
+  }
+}
+
+// src/consts.ts
+var TASK_COFHE_USE_FAUCET = "task:cofhe:usefaucet";
+var TASK_COFHE_MOCKS_SET_LOG_OPS = "task:cofhe-mocks:setlogops";
+var TASK_COFHE_MOCKS_DEPLOY = "task:cofhe-mocks:deploy";
+
+// src/deploy.ts
+var import_types2 = require("hardhat/types");
+var import_chalk = __toESM(require("chalk"));
+var import_ethers2 = require("ethers");
+var import_mock_contracts = require("@cofhe/mock-contracts");
+var import_sdk2 = require("@cofhe/sdk");
+
+// src/utils.ts
+var import_sdk = require("@cofhe/sdk");
+var import_chai = require("chai");
+var import_ethers = require("ethers");
+var import_hardhat_ethers_provider = require("@nomicfoundation/hardhat-ethers/internal/hardhat-ethers-provider");
+var deployMockContractFromArtifact = async (hre, artifact) => {
+  if (artifact.isFixed) {
+    await hre.network.provider.send("hardhat_setCode", [artifact.fixedAddress, artifact.deployedBytecode]);
+    return getFixedMockContract(hre, artifact);
+  }
+  const [signer] = await hre.ethers.getSigners();
+  const factory = new hre.ethers.ContractFactory(artifact.abi, artifact.bytecode, signer);
+  const contract = await factory.deploy(
+    /* constructor args */
+  );
+  await contract.waitForDeployment();
+  return contract;
+};
+var getFixedMockContract = async (hre, artifact) => {
+  if (!artifact.isFixed) {
+    throw new Error("Artifact is not fixed");
+  }
+  return await hre.ethers.getContractAt(artifact.abi, artifact.fixedAddress);
+};
+var mock_checkIsTestnet = async (fnName, provider) => {
+  const bytecode = await provider.getCode(import_sdk.MOCKS_ZK_VERIFIER_ADDRESS);
+  const isTestnet = bytecode.length === 0;
+  if (isTestnet) {
+    console.log(`${fnName} - skipped on non-testnet chain`);
+  }
+  return isTestnet;
+};
+var mock_getPlaintext = async (provider, ctHash) => {
+  if (await mock_checkIsTestnet(mock_getPlaintext.name, provider))
+    return;
+  const taskManager = new import_ethers.ethers.Contract(
+    import_sdk.TASK_MANAGER_ADDRESS,
+    ["function mockStorage(uint256) view returns (uint256)"],
+    provider
+  );
+  const plaintext = await taskManager.mockStorage(BigInt(ctHash));
+  return plaintext;
+};
+var mock_getPlaintextExists = async (provider, ctHash) => {
+  if (await mock_checkIsTestnet(mock_getPlaintextExists.name, provider))
+    return;
+  const taskManager = new import_ethers.ethers.Contract(
+    import_sdk.TASK_MANAGER_ADDRESS,
+    ["function inMockStorage(uint256) view returns (bool)"],
+    provider
+  );
+  const plaintextExists = await taskManager.inMockStorage(BigInt(ctHash));
+  return plaintextExists;
+};
+var mock_expectPlaintext = async (provider, ctHash, expectedValue) => {
+  if (await mock_checkIsTestnet(mock_expectPlaintext.name, provider))
+    return;
+  const plaintextExists = await mock_getPlaintextExists(provider, ctHash);
+  (0, import_chai.expect)(plaintextExists).equal(true, "Plaintext does not exist");
+  const plaintext = await mock_getPlaintext(provider, ctHash);
+  (0, import_chai.expect)(plaintext).equal(expectedValue, "Plaintext value is incorrect");
+};
+
+// src/deploy.ts
+var deployMocks = async (hre, options = {
+  deployTestBed: true,
+  gasWarning: true,
+  mocksDeployVerbosity: "v"
+}) => {
+  verbosity = options.mocksDeployVerbosity ?? "v";
+  const isHardhat = await getIsHardhat(hre);
+  if (!isHardhat) {
+    log("v", `cofhe-hardhat-plugin - deploy mocks - skipped on non-hardhat network ${hre.network.name}`, 0);
+    return;
+  }
+  log("vv", import_chalk.default.bold("cofhe-hardhat-plugin :: deploy mocks"), 0);
+  const taskManager = await deployMockTaskManager(hre);
+  logDeployment("MockTaskManager", await taskManager.getAddress());
+  const acl = await deployMockACL(hre);
+  logDeployment("MockACL", await acl.getAddress());
+  await linkTaskManagerAndACL(taskManager, acl);
+  log("vv", "ACL address set in TaskManager", 2);
+  await setVerifierSigner(taskManager);
+  log("vv", "Verifier signer set", 2);
+  await setDecryptResultSigner(taskManager);
+  log("vv", "Decrypt result signer set", 2);
+  await fundZkVerifierSigner(hre);
+  log("vv", `ZkVerifier signer (${import_sdk2.MOCKS_ZK_VERIFIER_SIGNER_ADDRESS}) funded`, 1);
+  const zkVerifierSignerBalance = await getZkVerifierSignerBalance(hre);
+  log("vv", `ETH balance: ${zkVerifierSignerBalance.toString()}`, 2);
+  const zkVerifier = await deployMockZkVerifier(hre);
+  logDeployment("MockZkVerifier", await zkVerifier.getAddress());
+  const thresholdNetwork = await deployMockThresholdNetwork(hre, acl);
+  logDeployment("MockThresholdNetwork", await thresholdNetwork.getAddress());
+  if (options.deployTestBed) {
+    const testBed = await deployTestBedContract(hre);
+    logDeployment("TestBed", await testBed.getAddress());
+  }
+  log("v", import_chalk.default.bold("cofhe-hardhat-plugin :: mocks deployed"), 0);
+  if (options.gasWarning) {
+    logEmpty("v");
+    logWarning(
+      "When using mocks, FHE operations (eg FHE.add / FHE.mul) report a higher gas price due to additional on-chain mocking logic. Deploy your contracts on a testnet chain to check the true gas costs.\n(Disable this warning by setting 'cofhe.gasWarning: false' in your hardhat config)",
+      0
+    );
+  }
+  logEmpty("v");
+};
+var getIsHardhat = async (hre) => {
+  return hre.network.name === "hardhat";
+};
+var deployMockTaskManager = async (hre) => {
+  const [signer] = await hre.ethers.getSigners();
+  const taskManager = await deployMockContractFromArtifact(hre, import_mock_contracts.MockTaskManagerArtifact);
+  const initTx = await taskManager.initialize(signer.address);
+  await initTx.wait();
+  const tmExists = await taskManager.exists();
+  if (!tmExists) {
+    throw new Error("MockTaskManager does not exist");
+  }
+  return taskManager;
+};
+var deployMockACL = async (hre) => {
+  const acl = await deployMockContractFromArtifact(hre, import_mock_contracts.MockACLArtifact);
+  const exists = await acl.exists();
+  if (!exists) {
+    throw new Error("MockACL does not exist");
+  }
+  return acl;
+};
+var fundZkVerifierSigner = async (hre) => {
+  const zkVerifierSigner = await hre.ethers.getSigner(import_sdk2.MOCKS_ZK_VERIFIER_SIGNER_ADDRESS);
+  await hre.network.provider.send("hardhat_setBalance", [
+    zkVerifierSigner.address,
+    "0x" + hre.ethers.parseEther("10").toString(16)
+  ]);
+};
+var getZkVerifierSignerBalance = async (hre) => {
+  return hre.ethers.provider.getBalance(import_sdk2.MOCKS_ZK_VERIFIER_SIGNER_ADDRESS);
+};
+var linkTaskManagerAndACL = async (taskManager, acl) => {
+  const aclAddress = await acl.getAddress();
+  const linkAclTx = await taskManager.setACLContract(aclAddress);
+  await linkAclTx.wait();
+};
+var setVerifierSigner = async (taskManager) => {
+  const signer = new import_ethers2.Wallet(import_sdk2.MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY);
+  const setSignerTx = await taskManager.setVerifierSigner(signer.address);
+  await setSignerTx.wait();
+};
+var setDecryptResultSigner = async (taskManager) => {
+  const signer = new import_ethers2.Wallet(import_sdk2.MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY);
+  const setSignerTx = await taskManager.setDecryptResultSigner(signer.address);
+  await setSignerTx.wait();
+};
+var deployMockZkVerifier = async (hre) => {
+  const zkVerifier = await deployMockContractFromArtifact(hre, import_mock_contracts.MockZkVerifierArtifact);
+  const zkVerifierExists = await zkVerifier.exists();
+  if (!zkVerifierExists) {
+    throw new Error("MockZkVerifier does not exist");
+  }
+  return zkVerifier;
+};
+var deployMockThresholdNetwork = async (hre, acl) => {
+  const thresholdNetwork = await deployMockContractFromArtifact(hre, import_mock_contracts.MockThresholdNetworkArtifact);
+  const initTx = await thresholdNetwork.initialize(import_sdk2.TASK_MANAGER_ADDRESS, await acl.getAddress());
+  await initTx.wait();
+  const exists = await thresholdNetwork.exists();
+  if (!exists) {
+    throw new Error("MockThresholdNetwork does not exist");
+  }
+  return thresholdNetwork;
+};
+var deployTestBedContract = async (hre) => {
+  return deployMockContractFromArtifact(hre, import_mock_contracts.TestBedArtifact);
+};
+var verbosity = "v";
+var log = (minVerbosity, message, indent = 1) => {
+  if (verbosity === "")
+    return;
+  if (minVerbosity === "vv" && verbosity !== "vv")
+    return;
+  console.log(import_chalk.default.green(`${"  ".repeat(indent)}\u2713 ${message}`));
+};
+var logEmpty = (minVerbosity = "v") => {
+  if (verbosity === "")
+    return;
+  if (minVerbosity === "vv" && verbosity !== "vv")
+    return;
+  console.log("");
+};
+var logWarning = (message, indent = 1) => {
+  if (verbosity === "")
+    return;
+  console.log(import_chalk.default.bold(import_chalk.default.yellow(`${"  ".repeat(indent)}\u26A0 NOTE:`)), message);
+};
+var logDeployment = (contractName, address) => {
+  if (verbosity !== "vv")
+    return;
+  const paddedName = `${contractName} deployed`.padEnd(36);
+  console.log(import_chalk.default.green(`  \u2713 ${paddedName} ${import_chalk.default.bold(address)}`));
+};
+
+// src/logging.ts
+var import_chalk2 = __toESM(require("chalk"));
+var import_types3 = require("hardhat/types");
+var import_mock_contracts2 = require("@cofhe/mock-contracts");
+var getLoggingEnabled = async (hre) => {
+  const taskManager = await getFixedMockContract(hre, import_mock_contracts2.MockTaskManagerArtifact);
+  return taskManager.logOps();
+};
+var setLoggingEnabled = async (hre, enabled) => {
+  const taskManager = await getFixedMockContract(hre, import_mock_contracts2.MockTaskManagerArtifact);
+  const tx = await taskManager.setLogOps(enabled);
+  await tx.wait();
+};
+var printLogsEnabledMessage = (closureMessage) => {
+  console.log("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  console.log(`\u2502 [COFHE-MOCKS]    \u2502 ${closureMessage}`);
+  console.log("\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+};
+var printLogsBlockEnd = () => {
+  console.log("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+};
+var mock_setLoggingEnabled = async (hre, enabled, closureName) => {
+  try {
+    const initiallyEnabled = await getLoggingEnabled(hre);
+    await setLoggingEnabled(hre, enabled);
+    if (enabled) {
+      printLogsEnabledMessage(`${closureName ? `"${import_chalk2.default.bold(closureName)}" logs:` : "Logs:"}`);
+    }
+    if (!enabled && initiallyEnabled) {
+      printLogsBlockEnd();
+    }
+  } catch (error) {
+    console.log(import_chalk2.default.red("mock_setLoggingEnabled error"), error);
+  }
+};
+var mock_withLogs = async (hre, closureName, closure) => {
+  const initiallyEnabled = await getLoggingEnabled(hre);
+  await setLoggingEnabled(hre, true);
+  printLogsEnabledMessage(`"${import_chalk2.default.bold(closureName)}" logs:`);
+  try {
+    await closure();
+  } finally {
+    printLogsBlockEnd();
+    if (!initiallyEnabled) {
+      await setLoggingEnabled(hre, false);
+    }
+  }
+};
+
+// src/index.ts
+var import_chains = require("@cofhe/sdk/chains");
+var import_mock_contracts3 = require("@cofhe/mock-contracts");
+(0, import_config.extendConfig)((config, userConfig) => {
+  if (userConfig.networks && userConfig.networks.localcofhe) {
+    return;
+  }
+  config.networks.localcofhe = {
+    gas: "auto",
+    gasMultiplier: 1.2,
+    gasPrice: "auto",
+    timeout: 1e4,
+    httpHeaders: {},
+    url: "http://127.0.0.1:42069",
+    accounts: [
+      "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80",
+      "0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d",
+      "0x5de4111afa1a4b94908f83103eb1f1706367c2e68ca870fc3fb9a804cdab365a",
+      "0x7c852118294e51e653712a81e05800f419141751be58f605c371e15141b007a6"
+    ]
+  };
+  if (!userConfig.networks?.["eth-sepolia"]) {
+    config.networks["eth-sepolia"] = {
+      url: process.env.SEPOLIA_RPC_URL ?? "https://ethereum-sepolia.publicnode.com",
+      accounts: process.env.PRIVATE_KEY ? [process.env.PRIVATE_KEY] : [],
+      chainId: 11155111,
+      gas: "auto",
+      gasMultiplier: 1.2,
+      gasPrice: "auto",
+      timeout: 6e4,
+      httpHeaders: {}
+    };
+  }
+  if (!userConfig.networks?.["arb-sepolia"]) {
+    config.networks["arb-sepolia"] = {
+      url: process.env.ARBITRUM_SEPOLIA_RPC_URL ?? "https://sepolia-rollup.arbitrum.io/rpc",
+      accounts: process.env.PRIVATE_KEY ? [process.env.PRIVATE_KEY] : [],
+      chainId: 421614,
+      gas: "auto",
+      gasMultiplier: 1.2,
+      gasPrice: "auto",
+      timeout: 6e4,
+      httpHeaders: {}
+    };
+  }
+  config.cofhe = {
+    logMocks: userConfig.cofhe?.logMocks ?? false,
+    gasWarning: userConfig.cofhe?.gasWarning ?? false,
+    mocksDeployVerbosity: userConfig.cofhe?.mocksDeployVerbosity ?? "v"
+  };
+});
+(0, import_config.task)(TASK_COFHE_USE_FAUCET, "Fund an account from the funder").addOptionalParam("address", "Address to fund", void 0, import_config.types.string).setAction(async ({ address }, hre) => {
+  const { network } = hre;
+  const { name: networkName } = network;
+  if (networkName !== "localcofhe") {
+    console.info(import_chalk3.default.yellow(`Programmatic faucet only supported for localcofhe`));
+    return;
+  }
+  if (!address) {
+    console.info(import_chalk3.default.red(`Failed to get address to fund`));
+    return;
+  }
+  console.info(import_chalk3.default.green(`Getting funds from faucet for ${address}`));
+  try {
+    await localcofheFundAccount(hre, address);
+  } catch (e) {
+    console.info(import_chalk3.default.red(`failed to get funds from localcofhe for ${address}: ${e}`));
+  }
+});
+(0, import_config.task)(TASK_COFHE_MOCKS_DEPLOY, "Deploys the mock contracts on the Hardhat network").addOptionalParam("deployTestBed", "Whether to deploy the test bed", true, import_config.types.boolean).setAction(async ({ deployTestBed }, hre) => {
+  await deployMocks(hre, {
+    deployTestBed: deployTestBed ?? true,
+    gasWarning: hre.config.cofhe.gasWarning ?? true,
+    mocksDeployVerbosity: hre.config.cofhe.mocksDeployVerbosity
+  });
+});
+(0, import_config.task)(import_task_names.TASK_TEST, "Deploy mock contracts on hardhat").setAction(async ({}, hre, runSuper) => {
+  const skipAutoDeploy = (() => {
+    const raw = process.env.COFHE_SKIP_MOCKS_DEPLOY ?? "";
+    const normalized = raw.trim().toLowerCase();
+    return normalized === "1" || normalized === "true" || normalized === "yes";
+  })();
+  if (!skipAutoDeploy) {
+    await deployMocks(hre, {
+      deployTestBed: true,
+      gasWarning: hre.config.cofhe.gasWarning ?? true,
+      mocksDeployVerbosity: hre.config.cofhe.mocksDeployVerbosity
+    });
+  }
+  return runSuper();
+});
+(0, import_config.task)(import_task_names.TASK_NODE, "Deploy mock contracts on hardhat").setAction(async ({}, hre, runSuper) => {
+  const skipAutoDeploy = (() => {
+    const raw = process.env.COFHE_SKIP_MOCKS_DEPLOY ?? "";
+    const normalized = raw.trim().toLowerCase();
+    return normalized === "1" || normalized === "true" || normalized === "yes";
+  })();
+  if (!skipAutoDeploy) {
+    await deployMocks(hre, {
+      deployTestBed: true,
+      gasWarning: hre.config.cofhe.gasWarning ?? true,
+      mocksDeployVerbosity: hre.config.cofhe.mocksDeployVerbosity
+    });
+  }
+  return runSuper();
+});
+(0, import_config.task)(TASK_COFHE_MOCKS_SET_LOG_OPS, "Set logging for the Mock CoFHE contracts").addParam("enable", "Whether to enable logging", false, import_config.types.boolean).setAction(async ({ enable }, hre) => {
+  await mock_setLoggingEnabled(hre, enable);
+});
+function buildHardhatPluginMocksConfig(mocksConfig) {
+  return {
+    ...mocksConfig,
+    encryptDelay: mocksConfig?.encryptDelay ?? 0
+  };
+}
+(0, import_config.extendEnvironment)((hre) => {
+  hre.cofhe = {
+    createConfig: async (config) => {
+      const zkvHhSigner = await hre.ethers.getImpersonatedSigner(import_sdk3.MOCKS_ZK_VERIFIER_SIGNER_ADDRESS);
+      const { walletClient: zkvWalletClient } = await (0, import_adapters.HardhatSignerAdapter)(zkvHhSigner);
+      const configWithZkvWalletClient = {
+        environment: "hardhat",
+        ...config,
+        mocks: buildHardhatPluginMocksConfig(config.mocks),
+        _internal: {
+          ...config._internal,
+          zkvWalletClient
+        }
+      };
+      return (0, import_node.createCofheConfig)(configWithZkvWalletClient);
+    },
+    createClient: (config) => {
+      return (0, import_node.createCofheClient)(config);
+    },
+    hardhatSignerAdapter: async (signer) => {
+      return (0, import_adapters.HardhatSignerAdapter)(signer);
+    },
+    connectWithHardhatSigner: async (client, signer) => {
+      const { publicClient, walletClient } = await (0, import_adapters.HardhatSignerAdapter)(signer);
+      return client.connect(publicClient, walletClient);
+    },
+    createClientWithBatteries: async (signer) => {
+      if (!signer) {
+        [signer] = await hre.ethers.getSigners();
+      }
+      const config = await hre.cofhe.createConfig({
+        environment: "hardhat",
+        supportedChains: [import_chains.hardhat]
+      });
+      const client = hre.cofhe.createClient(config);
+      await hre.cofhe.connectWithHardhatSigner(client, signer);
+      await client.permits.createSelf({
+        issuer: signer.address
+      });
+      return client;
+    },
+    mocks: {
+      withLogs: async (closureName, closure) => {
+        return mock_withLogs(hre, closureName, closure);
+      },
+      enableLogs: async (closureName) => {
+        return mock_setLoggingEnabled(hre, true, closureName);
+      },
+      disableLogs: async () => {
+        return mock_setLoggingEnabled(hre, false);
+      },
+      deployMocks: async (options = {}) => {
+        return deployMocks(hre, { mocksDeployVerbosity: hre.config.cofhe.mocksDeployVerbosity, ...options });
+      },
+      getPlaintext: async (ctHash) => {
+        const [signer] = await hre.ethers.getSigners();
+        return mock_getPlaintext(signer.provider, ctHash);
+      },
+      expectPlaintext: async (ctHash, expectedValue) => {
+        const [signer] = await hre.ethers.getSigners();
+        return mock_expectPlaintext(signer.provider, ctHash, expectedValue);
+      },
+      getMockTaskManager: async () => getFixedMockContract(hre, import_mock_contracts3.MockTaskManagerArtifact),
+      getMockACL: async () => {
+        const taskManager = await getFixedMockContract(hre, import_mock_contracts3.MockTaskManagerArtifact);
+        const aclAddress = await taskManager.acl();
+        return hre.ethers.getContractAt([...import_mock_contracts3.MockACLArtifact.abi], aclAddress);
+      },
+      getMockThresholdNetwork: async () => getFixedMockContract(hre, import_mock_contracts3.MockThresholdNetworkArtifact),
+      getMockZkVerifier: async () => getFixedMockContract(hre, import_mock_contracts3.MockZkVerifierArtifact),
+      getTestBed: async () => getFixedMockContract(hre, import_mock_contracts3.TestBedArtifact)
+    }
+  };
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TASK_COFHE_MOCKS_DEPLOY,
+  TASK_COFHE_MOCKS_SET_LOG_OPS,
+  TASK_COFHE_USE_FAUCET,
+  buildHardhatPluginMocksConfig,
+  deployMockContractFromArtifact,
+  deployMocks,
+  getFixedMockContract,
+  localcofheFundAccount,
+  localcofheFundWalletIfNeeded,
+  mock_expectPlaintext,
+  mock_getPlaintext,
+  mock_getPlaintextExists,
+  mock_setLoggingEnabled,
+  mock_withLogs
+});
+//# sourceMappingURL=index.js.map