@cofhe/hardhat-plugin 0.2.0 → 0.3.0

package/dist/index.mjs

@@ -7,7 +7,7 @@ import "@nomicfoundation/hardhat-ethers/signers";
 import {
   MOCKS_ZK_VERIFIER_SIGNER_ADDRESS as MOCKS_ZK_VERIFIER_SIGNER_ADDRESS2
 } from "@cofhe/sdk";
-import { createCofhesdkClient, createCofhesdkConfig } from "@cofhe/sdk/node";
+import { createCofheClient, createCofheConfig } from "@cofhe/sdk/node";
 import { HardhatSignerAdapter } from "@cofhe/sdk/adapters";
 
 // src/fund.ts
@@ -66,10 +66,6 @@ async function localcofheFundWalletIfNeeded(hre, walletAddress) {
 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";
-var TASK_MANAGER_ADDRESS = "0xeA30c4B8b44078Bbf8a6ef5b9f1eC1626C7848D9";
-var MOCKS_ZK_VERIFIER_ADDRESS = "0x0000000000000000000000000000000000000100";
-var MOCKS_QUERY_DECRYPTER_ADDRESS = "0x0000000000000000000000000000000000000200";
-var TEST_BED_ADDRESS = "0x0000000000000000000000000000000000000300";
 
 // src/deploy.ts
 import "hardhat/types";
@@ -79,163 +75,196 @@ import {
   MockTaskManagerArtifact,
   MockACLArtifact,
   MockZkVerifierArtifact,
-  MockQueryDecrypterArtifact,
+  MockThresholdNetworkArtifact,
   TestBedArtifact
 } from "@cofhe/mock-contracts";
-import { MOCKS_ZK_VERIFIER_SIGNER_ADDRESS } from "@cofhe/sdk";
-var deployMockTaskManager = async (hre) => {
-  const [signer] = await hre.ethers.getSigners();
-  await hardhatSetCode(hre, TASK_MANAGER_ADDRESS, MockTaskManagerArtifact.deployedBytecode);
-  const taskManager = await hre.ethers.getContractAt(MockTaskManagerArtifact.abi, TASK_MANAGER_ADDRESS);
-  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 ethersDeployContract(hre, MockACLArtifact.abi, MockACLArtifact.bytecode);
-  const exists = await acl.exists();
-  if (!exists) {
-    logError("MockACL does not exist", 2);
-    throw new Error("MockACL does not exist");
+import { TASK_MANAGER_ADDRESS as TASK_MANAGER_ADDRESS2, MOCKS_ZK_VERIFIER_SIGNER_ADDRESS } from "@cofhe/sdk";
+
+// src/utils.ts
+import { TASK_MANAGER_ADDRESS, MOCKS_ZK_VERIFIER_ADDRESS } from "@cofhe/sdk";
+import { expect } from "chai";
+import { ethers } from "ethers";
+import "@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);
   }
-  return acl;
+  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 deployMockZkVerifier = async (hre) => {
-  await hardhatSetCode(hre, MOCKS_ZK_VERIFIER_ADDRESS, MockZkVerifierArtifact.deployedBytecode);
-  const zkVerifier = await hre.ethers.getContractAt(MockZkVerifierArtifact.abi, MOCKS_ZK_VERIFIER_ADDRESS);
-  const zkVerifierExists = await zkVerifier.exists();
-  if (!zkVerifierExists) {
-    logError("MockZkVerifier does not exist", 2);
-    throw new Error("MockZkVerifier does not exist");
+var getFixedMockContract = async (hre, artifact) => {
+  if (!artifact.isFixed) {
+    throw new Error("Artifact is not fixed");
   }
-  return zkVerifier;
+  return await hre.ethers.getContractAt(artifact.abi, artifact.fixedAddress);
 };
-var deployMockQueryDecrypter = async (hre, acl) => {
-  await hardhatSetCode(hre, MOCKS_QUERY_DECRYPTER_ADDRESS, MockQueryDecrypterArtifact.deployedBytecode);
-  const queryDecrypter = await hre.ethers.getContractAt(MockQueryDecrypterArtifact.abi, MOCKS_QUERY_DECRYPTER_ADDRESS);
-  const initTx = await queryDecrypter.initialize(TASK_MANAGER_ADDRESS, await acl.getAddress());
-  await initTx.wait();
-  const queryDecrypterExists = await queryDecrypter.exists();
-  if (!queryDecrypterExists) {
-    logError("MockQueryDecrypter does not exist", 2);
-    throw new Error("MockQueryDecrypter does not exist");
+var mock_checkIsTestnet = async (fnName, provider) => {
+  const bytecode = await provider.getCode(MOCKS_ZK_VERIFIER_ADDRESS);
+  const isTestnet = bytecode.length === 0;
+  if (isTestnet) {
+    console.log(`${fnName} - skipped on non-testnet chain`);
   }
-  return queryDecrypter;
+  return isTestnet;
 };
-var deployTestBedContract = async (hre) => {
-  await hardhatSetCode(hre, TEST_BED_ADDRESS, TestBedArtifact.deployedBytecode);
-  const testBed = await hre.ethers.getContractAt(TestBedArtifact.abi, TEST_BED_ADDRESS);
-  await testBed.waitForDeployment();
-  return testBed;
+var mock_getPlaintext = async (provider, ctHash) => {
+  if (await mock_checkIsTestnet(mock_getPlaintext.name, provider))
+    return;
+  const taskManager = new ethers.Contract(
+    TASK_MANAGER_ADDRESS,
+    ["function mockStorage(uint256) view returns (uint256)"],
+    provider
+  );
+  const plaintext = await taskManager.mockStorage(ctHash);
+  return plaintext;
 };
-var fundZkVerifierSigner = async (hre) => {
-  const zkVerifierSigner = await hre.ethers.getSigner(MOCKS_ZK_VERIFIER_SIGNER_ADDRESS);
-  await hre.network.provider.send("hardhat_setBalance", [
-    zkVerifierSigner.address,
-    "0x" + hre.ethers.parseEther("10").toString(16)
-  ]);
+var mock_getPlaintextExists = async (provider, ctHash) => {
+  if (await mock_checkIsTestnet(mock_getPlaintextExists.name, provider))
+    return;
+  const taskManager = new ethers.Contract(
+    TASK_MANAGER_ADDRESS,
+    ["function inMockStorage(uint256) view returns (bool)"],
+    provider
+  );
+  const plaintextExists = await taskManager.inMockStorage(ctHash);
+  return plaintextExists;
 };
-var setTaskManagerACL = async (taskManager, acl) => {
-  const setAclTx = await taskManager.setACLContract(await acl.getAddress());
-  await setAclTx.wait();
+var mock_expectPlaintext = async (provider, ctHash, expectedValue) => {
+  if (await mock_checkIsTestnet(mock_expectPlaintext.name, provider))
+    return;
+  const plaintextExists = await mock_getPlaintextExists(provider, ctHash);
+  expect(plaintextExists).equal(true, "Plaintext does not exist");
+  const plaintext = await mock_getPlaintext(provider, ctHash);
+  expect(plaintext).equal(expectedValue, "Plaintext value is incorrect");
 };
+
+// src/deploy.ts
 var deployMocks = async (hre, options = {
   deployTestBed: true,
   gasWarning: true,
   silent: false
 }) => {
-  const isHardhat = await checkNetworkAndSkip(hre);
-  if (!isHardhat)
+  const isHardhat = await getIsHardhat(hre);
+  if (!isHardhat) {
+    logSuccess(`cofhe-hardhat-plugin - deploy mocks - skipped on non-hardhat network ${hre.network.name}`, 0);
     return;
-  const logEmptyIfNoisy = () => {
-    if (!options.silent) {
-      logEmpty();
-    }
-  };
-  const logSuccessIfNoisy = (message, indent = 0) => {
-    if (!options.silent) {
-      logSuccess(message, indent);
-    }
-  };
-  const logDeploymentIfNoisy = (contractName, address) => {
-    if (!options.silent) {
-      logDeployment(contractName, address);
-    }
-  };
-  const logWarningIfNoisy = (message, indent = 0) => {
-    if (!options.silent) {
-      logWarning(message, indent);
-    }
-  };
-  logEmptyIfNoisy();
-  logSuccessIfNoisy(chalk.bold("cofhe-hardhat-plugin :: deploy mocks"), 0);
-  logEmptyIfNoisy();
+  }
+  isSilent = options.silent ?? false;
+  logEmpty();
+  logSuccess(chalk.bold("cofhe-hardhat-plugin :: deploy mocks"), 0);
+  logEmpty();
   const taskManager = await deployMockTaskManager(hre);
-  logDeploymentIfNoisy("MockTaskManager", await taskManager.getAddress());
+  logDeployment("MockTaskManager", await taskManager.getAddress());
   const acl = await deployMockACL(hre);
-  logDeploymentIfNoisy("MockACL", await acl.getAddress());
-  await setTaskManagerACL(taskManager, acl);
-  logSuccessIfNoisy("ACL address set in TaskManager", 2);
+  logDeployment("MockACL", await acl.getAddress());
+  await linkTaskManagerAndACL(taskManager, acl);
+  logSuccess("ACL address set in TaskManager", 2);
   await fundZkVerifierSigner(hre);
-  logSuccessIfNoisy(`ZkVerifier signer (${MOCKS_ZK_VERIFIER_SIGNER_ADDRESS}) funded`, 1);
-  const zkVerifierSignerBalance = await hre.ethers.provider.getBalance(MOCKS_ZK_VERIFIER_SIGNER_ADDRESS);
-  logSuccessIfNoisy(`ETH balance: ${zkVerifierSignerBalance.toString()}`, 2);
+  logSuccess(`ZkVerifier signer (${MOCKS_ZK_VERIFIER_SIGNER_ADDRESS}) funded`, 1);
+  const zkVerifierSignerBalance = await getZkVerifierSignerBalance(hre);
+  logSuccess(`ETH balance: ${zkVerifierSignerBalance.toString()}`, 2);
   const zkVerifier = await deployMockZkVerifier(hre);
-  logDeploymentIfNoisy("MockZkVerifier", await zkVerifier.getAddress());
-  const queryDecrypter = await deployMockQueryDecrypter(hre, acl);
-  logDeploymentIfNoisy("MockQueryDecrypter", await queryDecrypter.getAddress());
+  logDeployment("MockZkVerifier", await zkVerifier.getAddress());
+  const thresholdNetwork = await deployMockThresholdNetwork(hre, acl);
+  logDeployment("MockThresholdNetwork", await thresholdNetwork.getAddress());
   if (options.deployTestBed) {
-    logSuccessIfNoisy("TestBed deployment enabled", 2);
+    logSuccess("TestBed deployment enabled", 2);
     const testBed = await deployTestBedContract(hre);
-    logDeploymentIfNoisy("TestBed", await testBed.getAddress());
+    logDeployment("TestBed", await testBed.getAddress());
   }
-  logEmptyIfNoisy();
-  logSuccessIfNoisy(chalk.bold("cofhe-hardhat-plugin :: mocks deployed successfully"), 0);
+  logEmpty();
+  logSuccess(chalk.bold("cofhe-hardhat-plugin :: mocks deployed successfully"), 0);
   if (options.gasWarning) {
-    logEmptyIfNoisy();
-    logWarningIfNoisy(
+    logEmpty();
+    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/sdk.gasWarning' to false in your hardhat config",
       0
     );
   }
-  logEmptyIfNoisy();
+  logEmpty();
 };
-var hardhatSetCode = async (hre, address, bytecode) => {
-  await hre.network.provider.send("hardhat_setCode", [address, bytecode]);
+var getIsHardhat = async (hre) => {
+  return hre.network.name === "hardhat";
 };
-var ethersDeployContract = async (hre, abi, bytecode) => {
+var deployMockTaskManager = async (hre) => {
   const [signer] = await hre.ethers.getSigners();
-  const factory = new hre.ethers.ContractFactory(abi, bytecode, signer);
-  const contract = await factory.deploy(
-    /* constructor args */
-  );
-  await contract.waitForDeployment();
-  return contract;
+  const taskManager = await deployMockContractFromArtifact(hre, 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 checkNetworkAndSkip = async (hre) => {
-  const network = hre.network.name;
-  const isHardhat = network === "hardhat";
-  if (!isHardhat)
-    logSuccess(`cofhe-hardhat-plugin - deploy mocks - skipped on non-hardhat network ${network}`, 0);
-  return isHardhat;
+var deployMockACL = async (hre) => {
+  const acl = await deployMockContractFromArtifact(hre, 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(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(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 deployMockZkVerifier = async (hre) => {
+  const zkVerifier = await deployMockContractFromArtifact(hre, 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, MockThresholdNetworkArtifact);
+  const initTx = await thresholdNetwork.initialize(TASK_MANAGER_ADDRESS2, 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, TestBedArtifact);
 };
+var isSilent = false;
 var logEmpty = () => {
+  if (isSilent)
+    return;
   console.log("");
 };
 var logSuccess = (message, indent = 1) => {
+  if (isSilent)
+    return;
   console.log(chalk.green(`${"  ".repeat(indent)}\u2713 ${message}`));
 };
 var logWarning = (message, indent = 1) => {
+  if (isSilent)
+    return;
   console.log(chalk.bold(chalk.yellow(`${"  ".repeat(indent)}\u26A0 NOTE:`)), message);
 };
-var logError = (message, indent = 1) => {
-  console.log(chalk.red(`${"  ".repeat(indent)}\u2717 ${message}`));
-};
 var logDeployment = (contractName, address) => {
+  if (isSilent)
+    return;
   const paddedName = `${contractName} deployed`.padEnd(36);
   logSuccess(`${paddedName} ${chalk.bold(address)}`);
 };
@@ -244,17 +273,14 @@ var logDeployment = (contractName, address) => {
 import chalk2 from "chalk";
 import "hardhat/types";
 import { MockTaskManagerArtifact as MockTaskManagerArtifact2 } from "@cofhe/mock-contracts";
-var getDeployedMockTaskManager = async (hre) => {
-  const taskManager = await hre.ethers.getContractAt(MockTaskManagerArtifact2.abi, TASK_MANAGER_ADDRESS);
-  return taskManager;
-};
 var getLoggingEnabled = async (hre) => {
-  const taskManager = await getDeployedMockTaskManager(hre);
-  return await taskManager.logOps();
+  const taskManager = await getFixedMockContract(hre, MockTaskManagerArtifact2);
+  return taskManager.logOps();
 };
 var setLoggingEnabled = async (hre, enabled) => {
-  const taskManager = await getDeployedMockTaskManager(hre);
-  await taskManager.setLogOps(enabled);
+  const taskManager = await getFixedMockContract(hre, MockTaskManagerArtifact2);
+  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");
@@ -289,65 +315,15 @@ var mock_withLogs = async (hre, closureName, closure) => {
   }
 };
 
-// src/utils.ts
-import { expect } from "chai";
-import { ethers } from "ethers";
-import "@nomicfoundation/hardhat-ethers/internal/hardhat-ethers-provider";
-var mock_checkIsTestnet = async (fnName, provider) => {
-  const bytecode = await provider.getCode(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 ethers.Contract(
-    TASK_MANAGER_ADDRESS,
-    ["function mockStorage(uint256) view returns (uint256)"],
-    provider
-  );
-  const plaintext = await taskManager.mockStorage(ctHash);
-  return plaintext;
-};
-var mock_getPlaintextExists = async (provider, ctHash) => {
-  if (await mock_checkIsTestnet(mock_getPlaintextExists.name, provider))
-    return;
-  const taskManager = new ethers.Contract(
-    TASK_MANAGER_ADDRESS,
-    ["function inMockStorage(uint256) view returns (bool)"],
-    provider
-  );
-  const plaintextExists = await taskManager.inMockStorage(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);
-  expect(plaintextExists).equal(true, "Plaintext does not exist");
-  const plaintext = await mock_getPlaintext(provider, ctHash);
-  expect(plaintext).equal(expectedValue, "Plaintext value is incorrect");
-};
-
 // src/index.ts
+import { hardhat } from "@cofhe/sdk/chains";
 import {
   MockACLArtifact as MockACLArtifact2,
-  MockQueryDecrypterArtifact as MockQueryDecrypterArtifact2,
+  MockThresholdNetworkArtifact as MockThresholdNetworkArtifact2,
   MockTaskManagerArtifact as MockTaskManagerArtifact3,
   MockZkVerifierArtifact as MockZkVerifierArtifact2,
   TestBedArtifact as TestBedArtifact2
 } from "@cofhe/mock-contracts";
-import { hardhat } from "@cofhe/sdk/chains";
-import {
-  MockACLArtifact as MockACLArtifact3,
-  MockQueryDecrypterArtifact as MockQueryDecrypterArtifact3,
-  MockTaskManagerArtifact as MockTaskManagerArtifact4,
-  MockZkVerifierArtifact as MockZkVerifierArtifact3,
-  TestBedArtifact as TestBedArtifact3
-} from "@cofhe/mock-contracts";
 extendConfig((config, userConfig) => {
   if (userConfig.networks && userConfig.networks.localcofhe) {
     return;
@@ -390,9 +366,9 @@ extendConfig((config, userConfig) => {
       httpHeaders: {}
     };
   }
-  config.cofhesdk = {
-    logMocks: userConfig.cofhesdk?.logMocks ?? true,
-    gasWarning: userConfig.cofhesdk?.gasWarning ?? true
+  config.cofhe = {
+    logMocks: userConfig.cofhe?.logMocks ?? true,
+    gasWarning: userConfig.cofhe?.gasWarning ?? true
   };
 });
 task(TASK_COFHE_USE_FAUCET, "Fund an account from the funder").addOptionalParam("address", "Address to fund", void 0, types.string).setAction(async ({ address }, hre) => {
@@ -416,44 +392,65 @@ task(TASK_COFHE_USE_FAUCET, "Fund an account from the funder").addOptionalParam(
 task(TASK_COFHE_MOCKS_DEPLOY, "Deploys the mock contracts on the Hardhat network").addOptionalParam("deployTestBed", "Whether to deploy the test bed", true, types.boolean).addOptionalParam("silent", "Whether to suppress output", false, types.boolean).setAction(async ({ deployTestBed, silent }, hre) => {
   await deployMocks(hre, {
     deployTestBed: deployTestBed ?? true,
-    gasWarning: hre.config.cofhesdk.gasWarning ?? true,
+    gasWarning: hre.config.cofhe.gasWarning ?? true,
     silent: silent ?? false
   });
 });
 task(TASK_TEST, "Deploy mock contracts on hardhat").setAction(async ({}, hre, runSuper) => {
-  await deployMocks(hre, {
-    deployTestBed: true,
-    gasWarning: hre.config.cofhesdk.gasWarning ?? true
-  });
+  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
+    });
+  }
   return runSuper();
 });
 task(TASK_NODE, "Deploy mock contracts on hardhat").setAction(async ({}, hre, runSuper) => {
-  await deployMocks(hre, {
-    deployTestBed: true,
-    gasWarning: hre.config.cofhesdk.gasWarning ?? true
-  });
+  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
+    });
+  }
   return runSuper();
 });
 task(TASK_COFHE_MOCKS_SET_LOG_OPS, "Set logging for the Mock CoFHE contracts").addParam("enable", "Whether to enable logging", false, types.boolean).setAction(async ({ enable }, hre) => {
   await mock_setLoggingEnabled(hre, enable);
 });
+function buildHardhatPluginMocksConfig(mocksConfig) {
+  return {
+    ...mocksConfig,
+    encryptDelay: mocksConfig?.encryptDelay ?? 0
+  };
+}
 extendEnvironment((hre) => {
-  hre.cofhesdk = {
-    createCofhesdkConfig: async (config) => {
+  hre.cofhe = {
+    createConfig: async (config) => {
       const zkvHhSigner = await hre.ethers.getImpersonatedSigner(MOCKS_ZK_VERIFIER_SIGNER_ADDRESS2);
       const { walletClient: zkvWalletClient } = await HardhatSignerAdapter(zkvHhSigner);
       const configWithZkvWalletClient = {
         environment: "hardhat",
         ...config,
+        mocks: buildHardhatPluginMocksConfig(config.mocks),
         _internal: {
           ...config._internal,
           zkvWalletClient
         }
       };
-      return createCofhesdkConfig(configWithZkvWalletClient);
+      return createCofheConfig(configWithZkvWalletClient);
     },
-    createCofhesdkClient: (config) => {
-      return createCofhesdkClient(config);
+    createClient: (config) => {
+      return createCofheClient(config);
     },
     hardhatSignerAdapter: async (signer) => {
       return HardhatSignerAdapter(signer);
@@ -462,16 +459,16 @@ extendEnvironment((hre) => {
       const { publicClient, walletClient } = await HardhatSignerAdapter(signer);
       return client.connect(publicClient, walletClient);
     },
-    createBatteriesIncludedCofhesdkClient: async (signer) => {
+    createClientWithBatteries: async (signer) => {
       if (!signer) {
         [signer] = await hre.ethers.getSigners();
       }
-      const config = await hre.cofhesdk.createCofhesdkConfig({
+      const config = await hre.cofhe.createConfig({
         environment: "hardhat",
         supportedChains: [hardhat]
       });
-      const client = hre.cofhesdk.createCofhesdkClient(config);
-      await hre.cofhesdk.connectWithHardhatSigner(client, signer);
+      const client = hre.cofhe.createClient(config);
+      await hre.cofhe.connectWithHardhatSigner(client, signer);
       await client.permits.createSelf({
         issuer: signer.address
       });
@@ -498,33 +495,26 @@ extendEnvironment((hre) => {
         const [signer] = await hre.ethers.getSigners();
         return mock_expectPlaintext(signer.provider, ctHash, expectedValue);
       },
-      getMockTaskManager: async () => {
-        return await hre.ethers.getContractAt(MockTaskManagerArtifact3.abi, MockTaskManagerArtifact3.fixedAddress);
-      },
+      getMockTaskManager: async () => getFixedMockContract(hre, MockTaskManagerArtifact3),
       getMockACL: async () => {
-        const tm = await hre.ethers.getContractAt(MockTaskManagerArtifact3.abi, MockTaskManagerArtifact3.fixedAddress);
-        const aclAddress = await tm.acl();
-        return await hre.ethers.getContractAt(MockACLArtifact2.abi, aclAddress);
+        const taskManager = await getFixedMockContract(hre, MockTaskManagerArtifact3);
+        const aclAddress = await taskManager.acl();
+        return hre.ethers.getContractAt(MockACLArtifact2.abi, aclAddress);
       },
-      getMockQueryDecrypter: async () => {
-        return await hre.ethers.getContractAt(MockQueryDecrypterArtifact2.abi, MockQueryDecrypterArtifact2.fixedAddress);
-      },
-      getMockZkVerifier: async () => {
-        return await hre.ethers.getContractAt(MockZkVerifierArtifact2.abi, MockZkVerifierArtifact2.fixedAddress);
-      },
-      getTestBed: async () => {
-        return await hre.ethers.getContractAt(TestBedArtifact2.abi, TestBedArtifact2.fixedAddress);
-      }
+      getMockThresholdNetwork: async () => getFixedMockContract(hre, MockThresholdNetworkArtifact2),
+      getMockZkVerifier: async () => getFixedMockContract(hre, MockZkVerifierArtifact2),
+      getTestBed: async () => getFixedMockContract(hre, TestBedArtifact2)
     }
   };
 });
 export {
-  MockACLArtifact3 as MockACLArtifact,
-  MockQueryDecrypterArtifact3 as MockQueryDecrypterArtifact,
-  MockTaskManagerArtifact4 as MockTaskManagerArtifact,
-  MockZkVerifierArtifact3 as MockZkVerifierArtifact,
-  TestBedArtifact3 as TestBedArtifact,
+  TASK_COFHE_MOCKS_DEPLOY,
+  TASK_COFHE_MOCKS_SET_LOG_OPS,
+  TASK_COFHE_USE_FAUCET,
+  buildHardhatPluginMocksConfig,
+  deployMockContractFromArtifact,
   deployMocks,
+  getFixedMockContract,
   localcofheFundAccount,
   localcofheFundWalletIfNeeded,
   mock_expectPlaintext,