@cofhe/hardhat-plugin 0.2.0 → 0.2.1

package/src/index.ts

@@ -6,10 +6,10 @@ import { extendConfig, extendEnvironment, task, types } from 'hardhat/config';
 import { TASK_TEST, TASK_NODE } from 'hardhat/builtin-tasks/task-names';
 import { HardhatEthersSigner } from '@nomicfoundation/hardhat-ethers/signers';
 import {
-  MOCKS_ZK_VERIFIER_SIGNER_ADDRESS,
   type CofhesdkClient,
   type CofhesdkConfig,
   type CofhesdkInputConfig,
+  MOCKS_ZK_VERIFIER_SIGNER_ADDRESS,
 } from '@cofhe/sdk';
 import { createCofhesdkClient, createCofhesdkConfig } from '@cofhe/sdk/node';
 import { HardhatSignerAdapter } from '@cofhe/sdk/adapters';
@@ -18,18 +18,11 @@ import { localcofheFundAccount } from './fund.js';
 import { TASK_COFHE_MOCKS_DEPLOY, TASK_COFHE_MOCKS_SET_LOG_OPS, TASK_COFHE_USE_FAUCET } from './consts.js';
 import { deployMocks, type DeployMocksArgs } from './deploy.js';
 import { mock_setLoggingEnabled, mock_withLogs } from './logging.js';
-import { mock_expectPlaintext } from './utils.js';
+import { getFixedMockContract, mock_expectPlaintext } from './utils.js';
 import { mock_getPlaintext } from './utils.js';
 import type { Contract } from 'ethers';
-import {
-  MockACLArtifact,
-  MockQueryDecrypterArtifact,
-  MockTaskManagerArtifact,
-  MockZkVerifierArtifact,
-  TestBedArtifact,
-} from '@cofhe/mock-contracts';
 import { hardhat } from '@cofhe/sdk/chains';
-export {
+import {
   MockACLArtifact,
   MockQueryDecrypterArtifact,
   MockTaskManagerArtifact,
@@ -186,6 +179,7 @@ task(TASK_COFHE_MOCKS_SET_LOG_OPS, 'Set logging for the Mock CoFHE contracts')
 
 // MOCK UTILS
 
+export * from './consts.js';
 export * from './utils.js';
 export * from './fund.js';
 export * from './logging.js';
@@ -417,23 +411,15 @@ extendEnvironment((hre) => {
         const [signer] = await hre.ethers.getSigners();
         return mock_expectPlaintext(signer.provider, ctHash, expectedValue);
       },
-      getMockTaskManager: async () => {
-        return await hre.ethers.getContractAt(MockTaskManagerArtifact.abi, MockTaskManagerArtifact.fixedAddress);
-      },
+      getMockTaskManager: async () => getFixedMockContract(hre, MockTaskManagerArtifact),
       getMockACL: async () => {
-        const tm = await hre.ethers.getContractAt(MockTaskManagerArtifact.abi, MockTaskManagerArtifact.fixedAddress);
-        const aclAddress = await tm.acl();
-        return await hre.ethers.getContractAt(MockACLArtifact.abi, aclAddress);
-      },
-      getMockQueryDecrypter: async () => {
-        return await hre.ethers.getContractAt(MockQueryDecrypterArtifact.abi, MockQueryDecrypterArtifact.fixedAddress);
-      },
-      getMockZkVerifier: async () => {
-        return await hre.ethers.getContractAt(MockZkVerifierArtifact.abi, MockZkVerifierArtifact.fixedAddress);
-      },
-      getTestBed: async () => {
-        return await hre.ethers.getContractAt(TestBedArtifact.abi, TestBedArtifact.fixedAddress);
+        const taskManager = await getFixedMockContract(hre, MockTaskManagerArtifact);
+        const aclAddress = await taskManager.acl();
+        return hre.ethers.getContractAt(MockACLArtifact.abi, aclAddress);
       },
+      getMockQueryDecrypter: async () => getFixedMockContract(hre, MockQueryDecrypterArtifact),
+      getMockZkVerifier: async () => getFixedMockContract(hre, MockZkVerifierArtifact),
+      getTestBed: async () => getFixedMockContract(hre, TestBedArtifact),
     },
   };
 });

package/src/logging.ts

@@ -1,23 +1,17 @@
 import chalk from 'chalk';
 import { type HardhatRuntimeEnvironment } from 'hardhat/types';
-import { TASK_MANAGER_ADDRESS } from './consts';
+import { getFixedMockContract } from './utils';
 import { MockTaskManagerArtifact } from '@cofhe/mock-contracts';
 
-const getDeployedMockTaskManager = async (hre: HardhatRuntimeEnvironment) => {
-  // Fetch the deployed MockTaskManager
-  const taskManager = await hre.ethers.getContractAt(MockTaskManagerArtifact.abi, TASK_MANAGER_ADDRESS);
-
-  return taskManager;
-};
-
-const getLoggingEnabled = async (hre: HardhatRuntimeEnvironment) => {
-  const taskManager = await getDeployedMockTaskManager(hre);
-  return await taskManager.logOps();
+const getLoggingEnabled = async (hre: HardhatRuntimeEnvironment): Promise<boolean> => {
+  const taskManager = await getFixedMockContract(hre, MockTaskManagerArtifact);
+  return taskManager.logOps();
 };
 
 const setLoggingEnabled = async (hre: HardhatRuntimeEnvironment, enabled: boolean) => {
-  const taskManager = await getDeployedMockTaskManager(hre);
-  await taskManager.setLogOps(enabled);
+  const taskManager = await getFixedMockContract(hre, MockTaskManagerArtifact);
+  const tx = await taskManager.setLogOps(enabled);
+  await tx.wait();
 };
 
 // prettier-ignore

package/src/utils.ts

@@ -1,7 +1,38 @@
-import { TASK_MANAGER_ADDRESS, MOCKS_ZK_VERIFIER_ADDRESS } from './consts.js';
+import { TASK_MANAGER_ADDRESS, MOCKS_ZK_VERIFIER_ADDRESS } from '@cofhe/sdk';
 import { expect } from 'chai';
-import { ethers } from 'ethers';
+import { Contract, ethers } from 'ethers';
 import { type HardhatEthersProvider } from '@nomicfoundation/hardhat-ethers/internal/hardhat-ethers-provider';
+import type { MockArtifact } from '@cofhe/mock-contracts';
+import type { HardhatRuntimeEnvironment } from 'hardhat/types';
+
+// Deployment utils
+
+/// Deploys a mock contract from a pre-built artifact from the mock-contracts package
+/// If the mock contract should be deployed to a fixed address, `hardhat_setCode` op is used to set the code at the fixed address
+/// Otherwise, we deploy the contract using ethers.js to a non-fixed address
+export const deployMockContractFromArtifact = async (hre: HardhatRuntimeEnvironment, artifact: MockArtifact) => {
+  // Use hardhat_setCode to deploy to fixed address
+  if (artifact.isFixed) {
+    await hre.network.provider.send('hardhat_setCode', [artifact.fixedAddress, artifact.deployedBytecode]);
+    return getFixedMockContract(hre, artifact);
+  }
+
+  // Use ethers.js to deploy to variable address
+  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 as Contract;
+};
+
+export const getFixedMockContract = async (hre: HardhatRuntimeEnvironment, artifact: MockArtifact) => {
+  if (!artifact.isFixed) {
+    throw new Error('Artifact is not fixed');
+  }
+  return await hre.ethers.getContractAt(artifact.abi, artifact.fixedAddress);
+};
+
+// Testing utils
 
 const mock_checkIsTestnet = async (fnName: string, provider: HardhatEthersProvider | ethers.JsonRpcProvider) => {
   // Testnet is checked by testing if MockZkVerifier is deployed