@cofhe/hardhat-plugin 0.2.0 → 0.2.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @cofhe/hardhat-plugin Changelog
 
+## 0.2.1
+
+### Patch Changes
+
+- 0000d5e: Mock contracts deployed to alternate fixed addresses to avoid collision with hardhat pre-compiles.
+- Updated dependencies [409bfdf]
+- Updated dependencies [ac47e2f]
+- Updated dependencies [0000d5e]
+- Updated dependencies [8af1b70]
+  - @cofhe/sdk@0.2.1
+  - @cofhe/mock-contracts@0.2.1
+
 ## 0.2.0
 
 ### Minor Changes

package/dist/index.d.mts

@@ -3,9 +3,9 @@ import { HardhatEthersSigner } from '@nomicfoundation/hardhat-ethers/signers';
 import { CofhesdkInputConfig, CofhesdkConfig, CofhesdkClient } from '@cofhe/sdk';
 import { HardhatRuntimeEnvironment } from 'hardhat/types';
 import * as ethers from 'ethers';
-import { ethers as ethers$1, Contract } from 'ethers';
-export { MockACLArtifact, MockQueryDecrypterArtifact, MockTaskManagerArtifact, MockZkVerifierArtifact, TestBedArtifact } from '@cofhe/mock-contracts';
+import { Contract, ethers as ethers$1 } from 'ethers';
 import { HardhatEthersProvider } from '@nomicfoundation/hardhat-ethers/internal/hardhat-ethers-provider';
+import { MockArtifact } from '@cofhe/mock-contracts';
 
 type DeployMocksArgs = {
     deployTestBed?: boolean;
@@ -14,6 +14,12 @@ type DeployMocksArgs = {
 };
 declare const deployMocks: (hre: HardhatRuntimeEnvironment, options?: DeployMocksArgs) => Promise<void>;
 
+declare const TASK_COFHE_USE_FAUCET = "task:cofhe:usefaucet";
+declare const TASK_COFHE_MOCKS_SET_LOG_OPS = "task:cofhe-mocks:setlogops";
+declare const TASK_COFHE_MOCKS_DEPLOY = "task:cofhe-mocks:deploy";
+
+declare const deployMockContractFromArtifact: (hre: HardhatRuntimeEnvironment, artifact: MockArtifact) => Promise<Contract>;
+declare const getFixedMockContract: (hre: HardhatRuntimeEnvironment, artifact: MockArtifact) => Promise<Contract>;
 declare const mock_getPlaintext: (provider: HardhatEthersProvider | ethers$1.JsonRpcProvider, ctHash: bigint) => Promise<any>;
 declare const mock_getPlaintextExists: (provider: HardhatEthersProvider | ethers$1.JsonRpcProvider, ctHash: bigint) => Promise<any>;
 declare const mock_expectPlaintext: (provider: HardhatEthersProvider | ethers$1.JsonRpcProvider, ctHash: bigint, expectedValue: bigint) => Promise<void>;
@@ -199,4 +205,4 @@ declare module 'hardhat/types/runtime' {
     }
 }
 
-export { type DeployMocksArgs, deployMocks, localcofheFundAccount, localcofheFundWalletIfNeeded, mock_expectPlaintext, mock_getPlaintext, mock_getPlaintextExists, mock_setLoggingEnabled, mock_withLogs };
+export { type DeployMocksArgs, TASK_COFHE_MOCKS_DEPLOY, TASK_COFHE_MOCKS_SET_LOG_OPS, TASK_COFHE_USE_FAUCET, deployMockContractFromArtifact, deployMocks, getFixedMockContract, localcofheFundAccount, localcofheFundWalletIfNeeded, mock_expectPlaintext, mock_getPlaintext, mock_getPlaintextExists, mock_setLoggingEnabled, mock_withLogs };

package/dist/index.d.ts

@@ -3,9 +3,9 @@ import { HardhatEthersSigner } from '@nomicfoundation/hardhat-ethers/signers';
 import { CofhesdkInputConfig, CofhesdkConfig, CofhesdkClient } from '@cofhe/sdk';
 import { HardhatRuntimeEnvironment } from 'hardhat/types';
 import * as ethers from 'ethers';
-import { ethers as ethers$1, Contract } from 'ethers';
-export { MockACLArtifact, MockQueryDecrypterArtifact, MockTaskManagerArtifact, MockZkVerifierArtifact, TestBedArtifact } from '@cofhe/mock-contracts';
+import { Contract, ethers as ethers$1 } from 'ethers';
 import { HardhatEthersProvider } from '@nomicfoundation/hardhat-ethers/internal/hardhat-ethers-provider';
+import { MockArtifact } from '@cofhe/mock-contracts';
 
 type DeployMocksArgs = {
     deployTestBed?: boolean;
@@ -14,6 +14,12 @@ type DeployMocksArgs = {
 };
 declare const deployMocks: (hre: HardhatRuntimeEnvironment, options?: DeployMocksArgs) => Promise<void>;
 
+declare const TASK_COFHE_USE_FAUCET = "task:cofhe:usefaucet";
+declare const TASK_COFHE_MOCKS_SET_LOG_OPS = "task:cofhe-mocks:setlogops";
+declare const TASK_COFHE_MOCKS_DEPLOY = "task:cofhe-mocks:deploy";
+
+declare const deployMockContractFromArtifact: (hre: HardhatRuntimeEnvironment, artifact: MockArtifact) => Promise<Contract>;
+declare const getFixedMockContract: (hre: HardhatRuntimeEnvironment, artifact: MockArtifact) => Promise<Contract>;
 declare const mock_getPlaintext: (provider: HardhatEthersProvider | ethers$1.JsonRpcProvider, ctHash: bigint) => Promise<any>;
 declare const mock_getPlaintextExists: (provider: HardhatEthersProvider | ethers$1.JsonRpcProvider, ctHash: bigint) => Promise<any>;
 declare const mock_expectPlaintext: (provider: HardhatEthersProvider | ethers$1.JsonRpcProvider, ctHash: bigint, expectedValue: bigint) => Promise<void>;
@@ -199,4 +205,4 @@ declare module 'hardhat/types/runtime' {
     }
 }
 
-export { type DeployMocksArgs, deployMocks, localcofheFundAccount, localcofheFundWalletIfNeeded, mock_expectPlaintext, mock_getPlaintext, mock_getPlaintextExists, mock_setLoggingEnabled, mock_withLogs };
+export { type DeployMocksArgs, TASK_COFHE_MOCKS_DEPLOY, TASK_COFHE_MOCKS_SET_LOG_OPS, TASK_COFHE_USE_FAUCET, deployMockContractFromArtifact, deployMocks, getFixedMockContract, localcofheFundAccount, localcofheFundWalletIfNeeded, mock_expectPlaintext, mock_getPlaintext, mock_getPlaintextExists, mock_setLoggingEnabled, mock_withLogs };

package/dist/index.js

@@ -30,12 +30,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  MockACLArtifact: () => import_mock_contracts4.MockACLArtifact,
-  MockQueryDecrypterArtifact: () => import_mock_contracts4.MockQueryDecrypterArtifact,
-  MockTaskManagerArtifact: () => import_mock_contracts4.MockTaskManagerArtifact,
-  MockZkVerifierArtifact: () => import_mock_contracts4.MockZkVerifierArtifact,
-  TestBedArtifact: () => import_mock_contracts4.TestBedArtifact,
+  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,
+  deployMockContractFromArtifact: () => deployMockContractFromArtifact,
   deployMocks: () => deployMocks,
+  getFixedMockContract: () => getFixedMockContract,
   localcofheFundAccount: () => localcofheFundAccount,
   localcofheFundWalletIfNeeded: () => localcofheFundWalletIfNeeded,
   mock_expectPlaintext: () => mock_expectPlaintext,
@@ -50,7 +50,7 @@ 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_sdk2 = require("@cofhe/sdk");
+var import_sdk3 = require("@cofhe/sdk");
 var import_node = require("@cofhe/sdk/node");
 var import_adapters = require("@cofhe/sdk/adapters");
 
@@ -110,21 +110,128 @@ 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
 var import_types2 = require("hardhat/types");
 var import_chalk = __toESM(require("chalk"));
-var import_ethers = require("ethers");
+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(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(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,
+  silent: false
+}) => {
+  const isHardhat = await getIsHardhat(hre);
+  if (!isHardhat) {
+    logSuccess(`cofhe-hardhat-plugin - deploy mocks - skipped on non-hardhat network ${hre.network.name}`, 0);
+    return;
+  }
+  isSilent = options.silent ?? false;
+  logEmpty();
+  logSuccess(import_chalk.default.bold("cofhe-hardhat-plugin :: deploy mocks"), 0);
+  logEmpty();
+  const taskManager = await deployMockTaskManager(hre);
+  logDeployment("MockTaskManager", await taskManager.getAddress());
+  const acl = await deployMockACL(hre);
+  logDeployment("MockACL", await acl.getAddress());
+  await linkTaskManagerAndACL(taskManager, acl);
+  logSuccess("ACL address set in TaskManager", 2);
+  await fundZkVerifierSigner(hre);
+  logSuccess(`ZkVerifier signer (${import_sdk2.MOCKS_ZK_VERIFIER_SIGNER_ADDRESS}) funded`, 1);
+  const zkVerifierSignerBalance = await getZkVerifierSignerBalance(hre);
+  logSuccess(`ETH balance: ${zkVerifierSignerBalance.toString()}`, 2);
+  const zkVerifier = await deployMockZkVerifier(hre);
+  logDeployment("MockZkVerifier", await zkVerifier.getAddress());
+  const queryDecrypter = await deployMockQueryDecrypter(hre, acl);
+  logDeployment("MockQueryDecrypter", await queryDecrypter.getAddress());
+  if (options.deployTestBed) {
+    logSuccess("TestBed deployment enabled", 2);
+    const testBed = await deployTestBedContract(hre);
+    logDeployment("TestBed", await testBed.getAddress());
+  }
+  logEmpty();
+  logSuccess(import_chalk.default.bold("cofhe-hardhat-plugin :: mocks deployed successfully"), 0);
+  if (options.gasWarning) {
+    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
+    );
+  }
+  logEmpty();
+};
+var getIsHardhat = async (hre) => {
+  return hre.network.name === "hardhat";
+};
 var deployMockTaskManager = async (hre) => {
   const [signer] = await hre.ethers.getSigners();
-  await hardhatSetCode(hre, TASK_MANAGER_ADDRESS, import_mock_contracts.MockTaskManagerArtifact.deployedBytecode);
-  const taskManager = await hre.ethers.getContractAt(import_mock_contracts.MockTaskManagerArtifact.abi, TASK_MANAGER_ADDRESS);
+  const taskManager = await deployMockContractFromArtifact(hre, import_mock_contracts.MockTaskManagerArtifact);
   const initTx = await taskManager.initialize(signer.address);
   await initTx.wait();
   const tmExists = await taskManager.exists();
@@ -134,146 +241,68 @@ var deployMockTaskManager = async (hre) => {
   return taskManager;
 };
 var deployMockACL = async (hre) => {
-  const acl = await ethersDeployContract(hre, import_mock_contracts.MockACLArtifact.abi, import_mock_contracts.MockACLArtifact.bytecode);
+  const acl = await deployMockContractFromArtifact(hre, import_mock_contracts.MockACLArtifact);
   const exists = await acl.exists();
   if (!exists) {
-    logError("MockACL does not exist", 2);
     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 deployMockZkVerifier = async (hre) => {
-  await hardhatSetCode(hre, MOCKS_ZK_VERIFIER_ADDRESS, import_mock_contracts.MockZkVerifierArtifact.deployedBytecode);
-  const zkVerifier = await hre.ethers.getContractAt(import_mock_contracts.MockZkVerifierArtifact.abi, MOCKS_ZK_VERIFIER_ADDRESS);
+  const zkVerifier = await deployMockContractFromArtifact(hre, import_mock_contracts.MockZkVerifierArtifact);
   const zkVerifierExists = await zkVerifier.exists();
   if (!zkVerifierExists) {
-    logError("MockZkVerifier does not exist", 2);
     throw new Error("MockZkVerifier does not exist");
   }
   return zkVerifier;
 };
 var deployMockQueryDecrypter = async (hre, acl) => {
-  await hardhatSetCode(hre, MOCKS_QUERY_DECRYPTER_ADDRESS, import_mock_contracts.MockQueryDecrypterArtifact.deployedBytecode);
-  const queryDecrypter = await hre.ethers.getContractAt(import_mock_contracts.MockQueryDecrypterArtifact.abi, MOCKS_QUERY_DECRYPTER_ADDRESS);
-  const initTx = await queryDecrypter.initialize(TASK_MANAGER_ADDRESS, await acl.getAddress());
+  const queryDecrypter = await deployMockContractFromArtifact(hre, import_mock_contracts.MockQueryDecrypterArtifact);
+  const initTx = await queryDecrypter.initialize(import_sdk2.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");
   }
   return queryDecrypter;
 };
 var deployTestBedContract = async (hre) => {
-  await hardhatSetCode(hre, TEST_BED_ADDRESS, import_mock_contracts.TestBedArtifact.deployedBytecode);
-  const testBed = await hre.ethers.getContractAt(import_mock_contracts.TestBedArtifact.abi, TEST_BED_ADDRESS);
-  await testBed.waitForDeployment();
-  return testBed;
-};
-var fundZkVerifierSigner = async (hre) => {
-  const zkVerifierSigner = await hre.ethers.getSigner(import_sdk.MOCKS_ZK_VERIFIER_SIGNER_ADDRESS);
-  await hre.network.provider.send("hardhat_setBalance", [
-    zkVerifierSigner.address,
-    "0x" + hre.ethers.parseEther("10").toString(16)
-  ]);
-};
-var setTaskManagerACL = async (taskManager, acl) => {
-  const setAclTx = await taskManager.setACLContract(await acl.getAddress());
-  await setAclTx.wait();
-};
-var deployMocks = async (hre, options = {
-  deployTestBed: true,
-  gasWarning: true,
-  silent: false
-}) => {
-  const isHardhat = await checkNetworkAndSkip(hre);
-  if (!isHardhat)
-    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(import_chalk.default.bold("cofhe-hardhat-plugin :: deploy mocks"), 0);
-  logEmptyIfNoisy();
-  const taskManager = await deployMockTaskManager(hre);
-  logDeploymentIfNoisy("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);
-  await fundZkVerifierSigner(hre);
-  logSuccessIfNoisy(`ZkVerifier signer (${import_sdk.MOCKS_ZK_VERIFIER_SIGNER_ADDRESS}) funded`, 1);
-  const zkVerifierSignerBalance = await hre.ethers.provider.getBalance(import_sdk.MOCKS_ZK_VERIFIER_SIGNER_ADDRESS);
-  logSuccessIfNoisy(`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());
-  if (options.deployTestBed) {
-    logSuccessIfNoisy("TestBed deployment enabled", 2);
-    const testBed = await deployTestBedContract(hre);
-    logDeploymentIfNoisy("TestBed", await testBed.getAddress());
-  }
-  logEmptyIfNoisy();
-  logSuccessIfNoisy(import_chalk.default.bold("cofhe-hardhat-plugin :: mocks deployed successfully"), 0);
-  if (options.gasWarning) {
-    logEmptyIfNoisy();
-    logWarningIfNoisy(
-      "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();
-};
-var hardhatSetCode = async (hre, address, bytecode) => {
-  await hre.network.provider.send("hardhat_setCode", [address, bytecode]);
-};
-var ethersDeployContract = async (hre, abi, bytecode) => {
-  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;
-};
-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;
+  return deployMockContractFromArtifact(hre, import_mock_contracts.TestBedArtifact);
 };
+var isSilent = false;
 var logEmpty = () => {
+  if (isSilent)
+    return;
   console.log("");
 };
 var logSuccess = (message, indent = 1) => {
+  if (isSilent)
+    return;
   console.log(import_chalk.default.green(`${"  ".repeat(indent)}\u2713 ${message}`));
 };
 var logWarning = (message, indent = 1) => {
+  if (isSilent)
+    return;
   console.log(import_chalk.default.bold(import_chalk.default.yellow(`${"  ".repeat(indent)}\u26A0 NOTE:`)), message);
 };
-var logError = (message, indent = 1) => {
-  console.log(import_chalk.default.red(`${"  ".repeat(indent)}\u2717 ${message}`));
-};
 var logDeployment = (contractName, address) => {
+  if (isSilent)
+    return;
   const paddedName = `${contractName} deployed`.padEnd(36);
   logSuccess(`${paddedName} ${import_chalk.default.bold(address)}`);
 };
@@ -282,17 +311,14 @@ var logDeployment = (contractName, address) => {
 var import_chalk2 = __toESM(require("chalk"));
 var import_types3 = require("hardhat/types");
 var import_mock_contracts2 = require("@cofhe/mock-contracts");
-var getDeployedMockTaskManager = async (hre) => {
-  const taskManager = await hre.ethers.getContractAt(import_mock_contracts2.MockTaskManagerArtifact.abi, TASK_MANAGER_ADDRESS);
-  return taskManager;
-};
 var getLoggingEnabled = async (hre) => {
-  const taskManager = await getDeployedMockTaskManager(hre);
-  return await taskManager.logOps();
+  const taskManager = await getFixedMockContract(hre, import_mock_contracts2.MockTaskManagerArtifact);
+  return taskManager.logOps();
 };
 var setLoggingEnabled = async (hre, enabled) => {
-  const taskManager = await getDeployedMockTaskManager(hre);
-  await taskManager.setLogOps(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");
@@ -327,53 +353,9 @@ var mock_withLogs = async (hre, closureName, closure) => {
   }
 };
 
-// src/utils.ts
-var import_chai = require("chai");
-var import_ethers2 = require("ethers");
-var import_hardhat_ethers_provider = require("@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 import_ethers2.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 import_ethers2.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);
-  (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/index.ts
-var import_mock_contracts3 = require("@cofhe/mock-contracts");
 var import_chains = require("@cofhe/sdk/chains");
-var import_mock_contracts4 = require("@cofhe/mock-contracts");
+var import_mock_contracts3 = require("@cofhe/mock-contracts");
 (0, import_config.extendConfig)((config, userConfig) => {
   if (userConfig.networks && userConfig.networks.localcofhe) {
     return;
@@ -466,7 +448,7 @@ var import_mock_contracts4 = require("@cofhe/mock-contracts");
 (0, import_config.extendEnvironment)((hre) => {
   hre.cofhesdk = {
     createCofhesdkConfig: async (config) => {
-      const zkvHhSigner = await hre.ethers.getImpersonatedSigner(import_sdk2.MOCKS_ZK_VERIFIER_SIGNER_ADDRESS);
+      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",
@@ -524,34 +506,26 @@ var import_mock_contracts4 = require("@cofhe/mock-contracts");
         const [signer] = await hre.ethers.getSigners();
         return mock_expectPlaintext(signer.provider, ctHash, expectedValue);
       },
-      getMockTaskManager: async () => {
-        return await hre.ethers.getContractAt(import_mock_contracts3.MockTaskManagerArtifact.abi, import_mock_contracts3.MockTaskManagerArtifact.fixedAddress);
-      },
+      getMockTaskManager: async () => getFixedMockContract(hre, import_mock_contracts3.MockTaskManagerArtifact),
       getMockACL: async () => {
-        const tm = await hre.ethers.getContractAt(import_mock_contracts3.MockTaskManagerArtifact.abi, import_mock_contracts3.MockTaskManagerArtifact.fixedAddress);
-        const aclAddress = await tm.acl();
-        return await hre.ethers.getContractAt(import_mock_contracts3.MockACLArtifact.abi, aclAddress);
-      },
-      getMockQueryDecrypter: async () => {
-        return await hre.ethers.getContractAt(import_mock_contracts3.MockQueryDecrypterArtifact.abi, import_mock_contracts3.MockQueryDecrypterArtifact.fixedAddress);
+        const taskManager = await getFixedMockContract(hre, import_mock_contracts3.MockTaskManagerArtifact);
+        const aclAddress = await taskManager.acl();
+        return hre.ethers.getContractAt(import_mock_contracts3.MockACLArtifact.abi, aclAddress);
       },
-      getMockZkVerifier: async () => {
-        return await hre.ethers.getContractAt(import_mock_contracts3.MockZkVerifierArtifact.abi, import_mock_contracts3.MockZkVerifierArtifact.fixedAddress);
-      },
-      getTestBed: async () => {
-        return await hre.ethers.getContractAt(import_mock_contracts3.TestBedArtifact.abi, import_mock_contracts3.TestBedArtifact.fixedAddress);
-      }
+      getMockQueryDecrypter: async () => getFixedMockContract(hre, import_mock_contracts3.MockQueryDecrypterArtifact),
+      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 = {
-  MockACLArtifact,
-  MockQueryDecrypterArtifact,
-  MockTaskManagerArtifact,
-  MockZkVerifierArtifact,
-  TestBedArtifact,
+  TASK_COFHE_MOCKS_DEPLOY,
+  TASK_COFHE_MOCKS_SET_LOG_OPS,
+  TASK_COFHE_USE_FAUCET,
+  deployMockContractFromArtifact,
   deployMocks,
+  getFixedMockContract,
   localcofheFundAccount,
   localcofheFundWalletIfNeeded,
   mock_expectPlaintext,