@cofhe/hardhat-plugin 0.1.1 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @cofhe/hardhat-plugin Changelog
 
+## 0.2.0
+
+### Minor Changes
+
+- 8fda09a: Removes `Promise<boolean>` return type from `client.connect(...)`, instead throws an error if the connection fails.
+- e0caeca: Adds `environment: 'node' | 'web' | 'hardhat' | 'react'` option to config. Exposed via `client.config.enviroment`. Automatically populated appropriately within the various `createCofhesdkConfig` functions.
+
+### Patch Changes
+
+- e121108: Fix ACL permission invalid issue. MockACL needs real deployment since etching doesn't call the constructor, so the EIP712 is uninitialized. Also adds additional utility functions to hardhat-plugin:
+
+  - `hre.cofhesdk.connectWithHardhatSigner(client, signer)` - Connect to client with hardhat ethers signer.
+  - `hre.cofhesdk.createBatteriesIncludedCofhesdkClient()` - Creates a batteries included client with signer connected.
+  - `hre.cofhesdk.mocks.getMockTaskManager()` - Gets deployed Mock Taskmanager
+  - `hre.cofhesdk.mocks.getMockACL()` - Gets deployed Mock ACL
+
+- Updated dependencies [8fda09a]
+- Updated dependencies [e121108]
+- Updated dependencies [4057a76]
+- Updated dependencies [dba2759]
+- Updated dependencies [e0caeca]
+- Updated dependencies [7c861af]
+- Updated dependencies [2a9d6c5]
+  - @cofhe/mock-contracts@0.2.0
+  - @cofhe/sdk@0.2.0
+
 ## 0.1.1
 
 ### Patch Changes

package/README.md

@@ -18,9 +18,9 @@ Add the plugin to your Hardhat config:
 
 ```javascript
 // hardhat.config.js or hardhat.config.ts
-require("cofhe-hardhat-plugin");
+require('cofhe-hardhat-plugin');
 // or if using TypeScript
-import "cofhe-hardhat-plugin";
+import 'cofhe-hardhat-plugin';
 
 module.exports = {
   // ... other config
@@ -83,15 +83,15 @@ The plugin exports several utility functions for working with mock contracts:
 
 ```typescript
 // Get plaintext value from a ciphertext hash
-import { mock_getPlaintext } from "cofhe-hardhat-plugin";
+import { mock_getPlaintext } from 'cofhe-hardhat-plugin';
 const plaintext = await mock_getPlaintext(provider, ctHash);
 
 // Check if a plaintext exists for a ciphertext hash
-import { mock_getPlaintextExists } from "cofhe-hardhat-plugin";
+import { mock_getPlaintextExists } from 'cofhe-hardhat-plugin';
 const exists = await mock_getPlaintextExists(provider, ctHash);
 
 // Test assertion for plaintext values
-import { mock_expectPlaintext } from "cofhe-hardhat-plugin";
+import { mock_expectPlaintext } from 'cofhe-hardhat-plugin';
 await mock_expectPlaintext(provider, ctHash, expectedValue);
 ```
 
@@ -99,15 +99,15 @@ await mock_expectPlaintext(provider, ctHash, expectedValue);
 
 ```typescript
 // Get the CoFHE environment based on network name
-import { getCofheEnvironmentFromNetwork } from "cofhe-hardhat-plugin";
+import { getCofheEnvironmentFromNetwork } from 'cofhe-hardhat-plugin';
 const environment = getCofheEnvironmentFromNetwork(networkName);
 
 // Check if a CoFHE environment is permitted for a given network
-import { isPermittedCofheEnvironment } from "cofhe-hardhat-plugin";
+import { isPermittedCofheEnvironment } from 'cofhe-hardhat-plugin';
 const isPermitted = isPermittedCofheEnvironment(hre, environmentName);
 
 // Initialize CoFHEjs with a Hardhat signer
-import { cofhejs_initializeWithHardhatSigner } from "cofhe-hardhat-plugin";
+import { cofhejs_initializeWithHardhatSigner } from 'cofhe-hardhat-plugin';
 await cofhejs_initializeWithHardhatSigner(signer, options);
 ```
 

package/dist/index.d.mts

@@ -1,10 +1,10 @@
 import { PublicClient, WalletClient } from 'viem';
 import { HardhatEthersSigner } from '@nomicfoundation/hardhat-ethers/signers';
-import { Result, CofhesdkInputConfig, CofhesdkConfig, CofhesdkClient } from '@cofhe/sdk';
+import { CofhesdkInputConfig, CofhesdkConfig, CofhesdkClient } from '@cofhe/sdk';
 import { HardhatRuntimeEnvironment } from 'hardhat/types';
-export { MockACLArtifact, MockQueryDecrypterArtifact, MockTaskManagerArtifact, MockZkVerifierArtifact, TestBedArtifact } from '@cofhe/mock-contracts';
 import * as ethers from 'ethers';
-import { ethers as ethers$1 } from 'ethers';
+import { ethers as ethers$1, Contract } from 'ethers';
+export { MockACLArtifact, MockQueryDecrypterArtifact, MockTaskManagerArtifact, MockZkVerifierArtifact, TestBedArtifact } from '@cofhe/mock-contracts';
 import { HardhatEthersProvider } from '@nomicfoundation/hardhat-ethers/internal/hardhat-ethers-provider';
 
 type DeployMocksArgs = {
@@ -18,11 +18,6 @@ declare const mock_getPlaintext: (provider: HardhatEthersProvider | ethers$1.Jso
 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>;
 
-declare const expectResultError: <T>(result: Result<T>, errorPartial: string) => void;
-declare const expectResultSuccess: <T>(result: Result<T>) => T;
-declare const expectResultValue: <T>(result: Result<T>, value: T) => T;
-declare const expectResultPartialValue: <T>(result: Result<T>, partial: Partial<T>) => T;
-
 /**
  * Sends funds to the specified address
  * @param hre Hardhat Runtime Environment
@@ -94,30 +89,20 @@ declare module 'hardhat/types/runtime' {
                 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: {
                 /**
                  * **[MOCKS ONLY]**
@@ -184,9 +169,34 @@ 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>;
             };
         };
     }
 }
 
-export { type DeployMocksArgs, deployMocks, expectResultError, expectResultPartialValue, expectResultSuccess, expectResultValue, localcofheFundAccount, localcofheFundWalletIfNeeded, mock_expectPlaintext, mock_getPlaintext, mock_getPlaintextExists, mock_setLoggingEnabled, mock_withLogs };
+export { type DeployMocksArgs, deployMocks, localcofheFundAccount, localcofheFundWalletIfNeeded, mock_expectPlaintext, mock_getPlaintext, mock_getPlaintextExists, mock_setLoggingEnabled, mock_withLogs };

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 import { PublicClient, WalletClient } from 'viem';
 import { HardhatEthersSigner } from '@nomicfoundation/hardhat-ethers/signers';
-import { Result, CofhesdkInputConfig, CofhesdkConfig, CofhesdkClient } from '@cofhe/sdk';
+import { CofhesdkInputConfig, CofhesdkConfig, CofhesdkClient } from '@cofhe/sdk';
 import { HardhatRuntimeEnvironment } from 'hardhat/types';
-export { MockACLArtifact, MockQueryDecrypterArtifact, MockTaskManagerArtifact, MockZkVerifierArtifact, TestBedArtifact } from '@cofhe/mock-contracts';
 import * as ethers from 'ethers';
-import { ethers as ethers$1 } from 'ethers';
+import { ethers as ethers$1, Contract } from 'ethers';
+export { MockACLArtifact, MockQueryDecrypterArtifact, MockTaskManagerArtifact, MockZkVerifierArtifact, TestBedArtifact } from '@cofhe/mock-contracts';
 import { HardhatEthersProvider } from '@nomicfoundation/hardhat-ethers/internal/hardhat-ethers-provider';
 
 type DeployMocksArgs = {
@@ -18,11 +18,6 @@ declare const mock_getPlaintext: (provider: HardhatEthersProvider | ethers$1.Jso
 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>;
 
-declare const expectResultError: <T>(result: Result<T>, errorPartial: string) => void;
-declare const expectResultSuccess: <T>(result: Result<T>) => T;
-declare const expectResultValue: <T>(result: Result<T>, value: T) => T;
-declare const expectResultPartialValue: <T>(result: Result<T>, partial: Partial<T>) => T;
-
 /**
  * Sends funds to the specified address
  * @param hre Hardhat Runtime Environment
@@ -94,30 +89,20 @@ declare module 'hardhat/types/runtime' {
                 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: {
                 /**
                  * **[MOCKS ONLY]**
@@ -184,9 +169,34 @@ 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>;
             };
         };
     }
 }
 
-export { type DeployMocksArgs, deployMocks, expectResultError, expectResultPartialValue, expectResultSuccess, expectResultValue, localcofheFundAccount, localcofheFundWalletIfNeeded, mock_expectPlaintext, mock_getPlaintext, mock_getPlaintextExists, mock_setLoggingEnabled, mock_withLogs };
+export { type DeployMocksArgs, deployMocks, localcofheFundAccount, localcofheFundWalletIfNeeded, mock_expectPlaintext, mock_getPlaintext, mock_getPlaintextExists, mock_setLoggingEnabled, mock_withLogs };

package/dist/index.js

@@ -30,16 +30,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  MockACLArtifact: () => import_mock_contracts3.MockACLArtifact,
-  MockQueryDecrypterArtifact: () => import_mock_contracts3.MockQueryDecrypterArtifact,
-  MockTaskManagerArtifact: () => import_mock_contracts3.MockTaskManagerArtifact,
-  MockZkVerifierArtifact: () => import_mock_contracts3.MockZkVerifierArtifact,
-  TestBedArtifact: () => import_mock_contracts3.TestBedArtifact,
+  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,
   deployMocks: () => deployMocks,
-  expectResultError: () => expectResultError,
-  expectResultPartialValue: () => expectResultPartialValue,
-  expectResultSuccess: () => expectResultSuccess,
-  expectResultValue: () => expectResultValue,
   localcofheFundAccount: () => localcofheFundAccount,
   localcofheFundWalletIfNeeded: () => localcofheFundWalletIfNeeded,
   mock_expectPlaintext: () => mock_expectPlaintext,
@@ -115,17 +111,16 @@ 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_ACL_ADDRESS = "0x0000000000000000000000000000000000000400";
 var MOCKS_ZK_VERIFIER_ADDRESS = "0x0000000000000000000000000000000000000100";
 var MOCKS_QUERY_DECRYPTER_ADDRESS = "0x0000000000000000000000000000000000000200";
 var TEST_BED_ADDRESS = "0x0000000000000000000000000000000000000300";
-var MOCKS_ZK_VERIFIER_SIGNER_ADDRESS = "0x6E12D8C87503D4287c294f2Fdef96ACd9DFf6bd2";
 
 // src/deploy.ts
 var import_types2 = require("hardhat/types");
 var import_chalk = __toESM(require("chalk"));
 var import_ethers = require("ethers");
 var import_mock_contracts = require("@cofhe/mock-contracts");
+var import_sdk = require("@cofhe/sdk");
 var deployMockTaskManager = async (hre) => {
   const [signer] = await hre.ethers.getSigners();
   await hardhatSetCode(hre, TASK_MANAGER_ADDRESS, import_mock_contracts.MockTaskManagerArtifact.deployedBytecode);
@@ -139,8 +134,7 @@ var deployMockTaskManager = async (hre) => {
   return taskManager;
 };
 var deployMockACL = async (hre) => {
-  await hardhatSetCode(hre, MOCKS_ACL_ADDRESS, import_mock_contracts.MockACLArtifact.deployedBytecode);
-  const acl = await hre.ethers.getContractAt(import_mock_contracts.MockACLArtifact.abi, MOCKS_ACL_ADDRESS);
+  const acl = await ethersDeployContract(hre, import_mock_contracts.MockACLArtifact.abi, import_mock_contracts.MockACLArtifact.bytecode);
   const exists = await acl.exists();
   if (!exists) {
     logError("MockACL does not exist", 2);
@@ -177,7 +171,7 @@ var deployTestBedContract = async (hre) => {
   return testBed;
 };
 var fundZkVerifierSigner = async (hre) => {
-  const zkVerifierSigner = await hre.ethers.getSigner(MOCKS_ZK_VERIFIER_SIGNER_ADDRESS);
+  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)
@@ -218,8 +212,6 @@ var deployMocks = async (hre, options = {
   logEmptyIfNoisy();
   logSuccessIfNoisy(import_chalk.default.bold("cofhe-hardhat-plugin :: deploy mocks"), 0);
   logEmptyIfNoisy();
-  logEmptyIfNoisy();
-  logSuccessIfNoisy("Mock contracts compiled", 1);
   const taskManager = await deployMockTaskManager(hre);
   logDeploymentIfNoisy("MockTaskManager", await taskManager.getAddress());
   const acl = await deployMockACL(hre);
@@ -227,8 +219,8 @@ var deployMocks = async (hre, options = {
   await setTaskManagerACL(taskManager, acl);
   logSuccessIfNoisy("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(`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());
@@ -253,6 +245,15 @@ var deployMocks = async (hre, options = {
 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";
@@ -369,30 +370,10 @@ var mock_expectPlaintext = async (provider, ctHash, expectedValue) => {
   (0, import_chai.expect)(plaintext).equal(expectedValue, "Plaintext value is incorrect");
 };
 
-// src/expectResultUtils.ts
-var import_sdk = require("@cofhe/sdk");
-var import_chai2 = require("chai");
-var expectResultError = (result, errorPartial) => {
-  (0, import_chai2.expect)(result.success).to.eq(false, "Result should be an error");
-  (0, import_chai2.expect)(result.error).to.include(errorPartial, `Error should contain error partial: ${errorPartial}`);
-};
-var expectResultSuccess = (result) => {
-  (0, import_chai2.expect)(result.success).to.eq(true, "Result should be a success");
-  return result.data;
-};
-var expectResultValue = (result, value) => {
-  (0, import_chai2.expect)(result.success).to.eq(true, "Result should be a success");
-  (0, import_chai2.expect)(result.data).to.eq(value, `Result should have the expected value ${value}`);
-  return result.data;
-};
-var expectResultPartialValue = (result, partial) => {
-  (0, import_chai2.expect)(result.success).to.eq(true, "Result should be a success");
-  (0, import_chai2.expect)(result.data).to.include(partial, `Result should have the expected partial ${partial}`);
-  return result.data;
-};
-
 // 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");
 (0, import_config.extendConfig)((config, userConfig) => {
   if (userConfig.networks && userConfig.networks.localcofhe) {
     return;
@@ -485,9 +466,10 @@ var import_mock_contracts3 = require("@cofhe/mock-contracts");
 (0, import_config.extendEnvironment)((hre) => {
   hre.cofhesdk = {
     createCofhesdkConfig: async (config) => {
-      const zkvHhSigner = await hre.ethers.getImpersonatedSigner(MOCKS_ZK_VERIFIER_SIGNER_ADDRESS);
+      const zkvHhSigner = await hre.ethers.getImpersonatedSigner(import_sdk2.MOCKS_ZK_VERIFIER_SIGNER_ADDRESS);
       const { walletClient: zkvWalletClient } = await (0, import_adapters.HardhatSignerAdapter)(zkvHhSigner);
       const configWithZkvWalletClient = {
+        environment: "hardhat",
         ...config,
         _internal: {
           ...config._internal,
@@ -502,21 +484,24 @@ var import_mock_contracts3 = require("@cofhe/mock-contracts");
     hardhatSignerAdapter: async (signer) => {
       return (0, import_adapters.HardhatSignerAdapter)(signer);
     },
-    expectResultSuccess: async (result) => {
-      const awaitedResult = await result;
-      return expectResultSuccess(awaitedResult);
-    },
-    expectResultError: async (result, errorPartial) => {
-      const awaitedResult = await result;
-      return expectResultError(awaitedResult, errorPartial);
-    },
-    expectResultValue: async (result, value) => {
-      const awaitedResult = await result;
-      return expectResultValue(awaitedResult, value);
+    connectWithHardhatSigner: async (client, signer) => {
+      const { publicClient, walletClient } = await (0, import_adapters.HardhatSignerAdapter)(signer);
+      return client.connect(publicClient, walletClient);
     },
-    expectResultPartialValue: async (result, partial) => {
-      const awaitedResult = await result;
-      return expectResultPartialValue(awaitedResult, partial);
+    createBatteriesIncludedCofhesdkClient: async (signer) => {
+      if (!signer) {
+        [signer] = await hre.ethers.getSigners();
+      }
+      const config = await hre.cofhesdk.createCofhesdkConfig({
+        environment: "hardhat",
+        supportedChains: [import_chains.hardhat]
+      });
+      const client = hre.cofhesdk.createCofhesdkClient(config);
+      await hre.cofhesdk.connectWithHardhatSigner(client, signer);
+      await client.permits.createSelf({
+        issuer: signer.address
+      });
+      return client;
     },
     mocks: {
       withLogs: async (closureName, closure) => {
@@ -538,6 +523,23 @@ var import_mock_contracts3 = require("@cofhe/mock-contracts");
       expectPlaintext: async (ctHash, expectedValue) => {
         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);
+      },
+      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);
+      },
+      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);
       }
     }
   };
@@ -550,10 +552,6 @@ var import_mock_contracts3 = require("@cofhe/mock-contracts");
   MockZkVerifierArtifact,
   TestBedArtifact,
   deployMocks,
-  expectResultError,
-  expectResultPartialValue,
-  expectResultSuccess,
-  expectResultValue,
   localcofheFundAccount,
   localcofheFundWalletIfNeeded,
   mock_expectPlaintext,