@cofhe/hardhat-plugin 0.1.1 → 0.2.1

package/src/index.ts

@@ -1,33 +1,28 @@
 /* eslint-disable no-empty-pattern */
 /* eslint-disable turbo/no-undeclared-env-vars */
-/* eslint-disable no-unused-vars */
 import chalk from 'chalk';
 import { type PublicClient, type WalletClient } from 'viem';
 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 { type CofhesdkClient, type CofhesdkConfig, type CofhesdkInputConfig, type Result } from '@cofhe/sdk';
+import {
+  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';
 
 import { localcofheFundAccount } from './fund.js';
-import {
-  MOCKS_ZK_VERIFIER_SIGNER_ADDRESS,
-  TASK_COFHE_MOCKS_DEPLOY,
-  TASK_COFHE_MOCKS_SET_LOG_OPS,
-  TASK_COFHE_USE_FAUCET,
-} from './consts.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 { hardhat } from '@cofhe/sdk/chains';
 import {
-  expectResultError,
-  expectResultPartialValue,
-  expectResultSuccess,
-  expectResultValue,
-} from './expectResultUtils.js';
-export {
   MockACLArtifact,
   MockQueryDecrypterArtifact,
   MockTaskManagerArtifact,
@@ -184,8 +179,8 @@ 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 './expectResultUtils.js';
 export * from './fund.js';
 export * from './logging.js';
 export * from './deploy.js';
@@ -217,35 +212,21 @@ declare module 'hardhat/types/runtime' {
       hardhatSignerAdapter: (
         signer: HardhatEthersSigner
       ) => Promise<{ publicClient: PublicClient; walletClient: WalletClient }>;
-
-      /**
-       * Assert that a Result type returned from a function is successful and return its value (result.success === true)
-       * @param {Result<T>} result - The Result to check
-       * @returns {T} The inner data of the Result (non null)
-       */
-      expectResultSuccess: <T>(result: Result<T> | Promise<Result<T>>) => Promise<T>;
-
       /**
-       * Assert that a Result type contains an error matching the partial string (result.success === false && result.error.includes(errorPartial))
-       * @param {Result<T>} result - The Result to check
-       * @param {string} errorPartial - The partial error string to match
-       */
-      expectResultError: <T>(result: Result<T> | Promise<Result<T>>, errorPartial: string) => Promise<void>;
-
-      /**
-       * Assert that a Result type contains a specific value (result.success === true && result.data === value)
-       * @param {Result<T>} result - The Result to check
-       * @param {T} value - The inner data of the Result (non null)
+       * Connect a CoFHE SDK client with a Hardhat ethers signer
+       * @param {CofhesdkClient} client - The CoFHE SDK client to connect
+       * @param {HardhatEthersSigner} signer - The Hardhat ethers signer to use
+       * @returns {Promise<void>}
        */
-      expectResultValue: <T>(result: Result<T> | Promise<Result<T>>, value: T) => Promise<T>;
-
+      connectWithHardhatSigner: (client: CofhesdkClient, signer: HardhatEthersSigner) => Promise<void>;
       /**
-       * Assert that a Result type contains a value matching the partial object (result.success === true && result.data.includes(partial))
-       * @param {Result<T>} result - The Result to check
-       * @param {Partial<T>} partial - The partial object to match against
-       * @returns {T} The inner data of the Result (non null)
+       * Create and connect to a batteries included client.
+       * Also generates a self-usage a permit for the signer.
+       * If customization is needed, use createCofhesdkClient and connectWithHardhatSigner.
+       * @param {HardhatEthersSigner} signer - The Hardhat ethers signer to use (optional - defaults to first signer)
+       * @returns {Promise<CofhesdkClient>} The CoFHE SDK client instance
        */
-      expectResultPartialValue: <T>(result: Result<T> | Promise<Result<T>>, partial: Partial<T>) => Promise<T>;
+      createBatteriesIncludedCofhesdkClient: (signer?: HardhatEthersSigner) => Promise<CofhesdkClient>;
 
       mocks: {
         /**
@@ -318,6 +299,36 @@ declare module 'hardhat/types/runtime' {
          * @param {bigint} expectedValue - The expected plaintext value
          */
         expectPlaintext: (ctHash: bigint, expectedValue: bigint) => Promise<void>;
+
+        /**
+         * Get the MockTaskManager contract
+         * @returns {Promise<Contract>} The MockTaskManager contract
+         */
+        getMockTaskManager: () => Promise<Contract>;
+
+        /**
+         * Get the MockACL contract
+         * @returns {Promise<Contract>} The MockACL contract
+         */
+        getMockACL: () => Promise<Contract>;
+
+        /**
+         * Get the MockQueryDecrypter contract
+         * @returns {Promise<Contract>} The MockQueryDecrypter contract
+         */
+        getMockQueryDecrypter: () => Promise<Contract>;
+
+        /**
+         * Get the MockZkVerifier contract
+         * @returns {Promise<Contract>} The MockZkVerifier contract
+         */
+        getMockZkVerifier: () => Promise<Contract>;
+
+        /**
+         * Get the TestBed contract
+         * @returns {Promise<Contract>} The TestBed contract
+         */
+        getTestBed: () => Promise<Contract>;
       };
     };
   }
@@ -333,6 +344,7 @@ extendEnvironment((hre) => {
 
       // Inject zkv wallet client into config
       const configWithZkvWalletClient = {
+        environment: 'hardhat' as const,
         ...config,
         _internal: {
           ...config._internal,
@@ -348,21 +360,35 @@ extendEnvironment((hre) => {
     hardhatSignerAdapter: async (signer: HardhatEthersSigner) => {
       return HardhatSignerAdapter(signer);
     },
-    expectResultSuccess: async <T>(result: Result<T> | Promise<Result<T>>) => {
-      const awaitedResult = await result;
-      return expectResultSuccess(awaitedResult);
-    },
-    expectResultError: async <T>(result: Result<T> | Promise<Result<T>>, errorPartial: string) => {
-      const awaitedResult = await result;
-      return expectResultError(awaitedResult, errorPartial);
+    connectWithHardhatSigner: async (client: CofhesdkClient, signer: HardhatEthersSigner) => {
+      const { publicClient, walletClient } = await HardhatSignerAdapter(signer);
+      return client.connect(publicClient, walletClient);
     },
-    expectResultValue: async <T>(result: Result<T> | Promise<Result<T>>, value: T) => {
-      const awaitedResult = await result;
-      return expectResultValue(awaitedResult, value);
-    },
-    expectResultPartialValue: async <T>(result: Result<T> | Promise<Result<T>>, partial: Partial<T>) => {
-      const awaitedResult = await result;
-      return expectResultPartialValue(awaitedResult, partial);
+    createBatteriesIncludedCofhesdkClient: async (signer?: HardhatEthersSigner) => {
+      // Get signer if not provided
+      if (!signer) {
+        [signer] = await hre.ethers.getSigners();
+      }
+
+      // Create config
+      const config = await hre.cofhesdk.createCofhesdkConfig({
+        environment: 'hardhat',
+        supportedChains: [hardhat],
+      });
+
+      // Create client
+      const client = hre.cofhesdk.createCofhesdkClient(config);
+
+      // Connect client
+      await hre.cofhesdk.connectWithHardhatSigner(client, signer);
+
+      // Create self-usage permit
+      await client.permits.createSelf({
+        issuer: signer.address,
+      });
+
+      // Return client
+      return client;
     },
     mocks: {
       withLogs: async (closureName: string, closure: () => Promise<void>) => {
@@ -385,6 +411,15 @@ extendEnvironment((hre) => {
         const [signer] = await hre.ethers.getSigners();
         return mock_expectPlaintext(signer.provider, ctHash, expectedValue);
       },
+      getMockTaskManager: async () => getFixedMockContract(hre, MockTaskManagerArtifact),
+      getMockACL: async () => {
+        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

package/src/expectResultUtils.ts

@@ -1,24 +0,0 @@
-import { type Result } from '@cofhe/sdk';
-import { expect } from 'chai';
-
-export const expectResultError = <T>(result: Result<T>, errorPartial: string) => {
-  expect(result.success).to.eq(false, 'Result should be an error');
-  expect(result.error).to.include(errorPartial, `Error should contain error partial: ${errorPartial}`);
-};
-
-export const expectResultSuccess = <T>(result: Result<T>): T => {
-  expect(result.success).to.eq(true, 'Result should be a success');
-  return result.data!;
-};
-
-export const expectResultValue = <T>(result: Result<T>, value: T): T => {
-  expect(result.success).to.eq(true, 'Result should be a success');
-  expect(result.data).to.eq(value, `Result should have the expected value ${value}`);
-  return result.data!;
-};
-
-export const expectResultPartialValue = <T>(result: Result<T>, partial: Partial<T>): T => {
-  expect(result.success).to.eq(true, 'Result should be a success');
-  expect(result.data).to.include(partial, `Result should have the expected partial ${partial}`);
-  return result.data!;
-};