@cofhe/hardhat-plugin 0.0.0-alpha-20260409113701

package/CHANGELOG.md

@@ -0,0 +1,170 @@
+# @cofhe/hardhat-plugin Changelog
+
+## 0.0.0-alpha-20260409113701
+
+### Minor Changes
+
+- f78beb7: Add `@cofhe/hardhat-3-plugin` and `@cofhe/foundry-plugin` packages.
+
+  **`@cofhe/hardhat-3-plugin`** — Hardhat 3 plugin with the same mock contract deployment, `network.cofhe` API, logging, and faucet task as the v2 plugin, adapted to the Hardhat 3 plugin/hook model.
+
+  **`@cofhe/foundry-plugin`** — Foundry test utilities: `CofheTest` base contract (`deployMocks`, `expectPlaintext`, `getPlaintext`) and `CofheClient` SDK mock (`connect`, `createInE*`, `decryptForTx`, `decryptForView`, permits). Usable as a git submodule or npm package, with `remappings.txt` for Hardhat 3 Solidity test compatibility.
+
+  **`mocksDeployVerbosity` config option** added to both Hardhat plugins:
+
+  - `''` — silent
+  - `'v'` — single summary line (new default)
+  - `'vv'` — full per-contract deployment logs (previous default behavior)
+
+### Patch Changes
+
+- Updated dependencies [788a6e2]
+- Updated dependencies [9a06012]
+- Updated dependencies [503536a]
+  - @cofhe/sdk@0.0.0-alpha-20260409113701
+  - @cofhe/mock-contracts@0.0.0-alpha-20260409113701
+
+## 0.4.0
+
+### Patch Changes
+
+- Updated dependencies [e446642]
+  - @cofhe/sdk@0.4.0
+  - @cofhe/mock-contracts@0.4.0
+
+## 0.3.2
+
+### Patch Changes
+
+- d4e86ea: Aligns with CTA encrypted variables bytes32 representation.
+
+  - **@cofhe/hardhat-plugin**: `hre.cofhe.mocks.getTestBed()`, `getMockTaskManager()`, `getMockACL()`, `getMockThresholdNetwork()`, and `getMockZkVerifier()` now return typed contracts (typechain interfaces) instead of untyped `Contract`. `getPlaintext(ctHash)` and `expectPlaintext(ctHash, value)` now accept bytes32 ctHashes as `string` support cofhe-contracts 0.1.0 CTA changes.
+  - **@cofhe/mock-contracts**: Export typechain-generated contract types (`TestBed`, `MockACL`, `MockTaskManager`, `MockZkVerifier`, `MockThresholdNetwork`) for use with the hardhat plugin. Typechain is run from artifact ABIs only; factory files are not generated.
+  - **@cofhe/abi**: CTA-related types use `bytes32` (string) instead of `uint256`. Decryption and return-type helpers aligned with cofhe-contracts 0.1.0.
+  - **@cofhe/sdk**: Decryption APIs (`decryptForTx`, `decryptForView`, and related builders) now also accept `string` for ciphertext hashes (bytes32) as well as `bigint`.
+
+- Updated dependencies [d4e86ea]
+- Updated dependencies [0feaf3f]
+  - @cofhe/sdk@0.3.2
+  - @cofhe/mock-contracts@0.3.2
+
+## 0.3.1
+
+### Patch Changes
+
+- 370f0c7: no-op
+- Updated dependencies [370f0c7]
+  - @cofhe/mock-contracts@0.3.1
+  - @cofhe/sdk@0.3.1
+
+## 0.3.0
+
+### Minor Changes
+
+- 35024b6: Remove `sdk` from function names and exported types. Rename:
+
+  - `createCofhesdkConfig` -> `createCofheConfig`
+  - `createCofhesdkClient` -> `createCofheClient`
+  - `hre.cofhesdk.*` -> `hre.cofhe.*`
+  - `hre.cofhesdk.createCofheConfig()` → `hre.cofhe.createConfig()`
+  - `hre.cofhesdk.createCofheClient()` → `hre.cofhe.createClient()`
+  - `hre.cofhesdk.createBatteriesIncludedCofheClient()` → `hre.cofhe.createClientWithBatteries()`
+
+- 29c2401: implement decrypt-with-proof flows and related tests:
+
+  - Implement production `decryptForTx` backed by Threshold Network `POST /decrypt`, with explicit permit vs global-allowance selection.
+  - Rename mocks “Query Decrypter” -> “Threshold Network” and update SDK constants/contracts/artifacts accordingly.
+  - Extend mock contracts + hardhat plugin to publish & verify decryption results on-chain, and add end-to-end integration tests.
+
+### Patch Changes
+
+- 5467d77: Adds `config.mocks.encryptDelay: number | [number, number, number, number, number]` to allow configurable mock encryption delay. Defaults to 0 delay on hardhat to keep tests quick.
+- Updated dependencies [35024b6]
+- Updated dependencies [5467d77]
+- Updated dependencies [73b1502]
+- Updated dependencies [29c2401]
+- Updated dependencies [650ea48]
+  - @cofhe/mock-contracts@0.3.0
+  - @cofhe/sdk@0.3.0
+
+## 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
+
+- 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
+
+- a1d1323: Add repository info to package.json of public packages to fix npm publish provenance issue.
+- d232d11: Ensure publish includes correct src and dist files
+- b6521fb: Update publish workflow to create versioning PR upon merge with changeset.
+- Updated dependencies [a1d1323]
+- Updated dependencies [d232d11]
+- Updated dependencies [b6521fb]
+  - @cofhe/mock-contracts@0.1.1
+  - @cofhe/sdk@0.1.1
+
+## 0.1.0
+
+### Minor Changes
+
+- 8d41cf2: Combine existing packages into more reasonable defaults. New package layout is @cofhe/sdk (includes all the core logic for configuring and creating a @cofhe/sdk client, encrypting values, and decrypting handles), mock-contracts, hardhat-plugin, and react.
+- a83facb: Prepare for initial release. Rename scope from `@cofhesdk` to `@cofhe` and rename `cofhesdk` package to `@cofhe/sdk`. Create `publish.yml` to publish `beta` packages on merged PR, and `latest` on changeset PR.
+- 58e93a8: Migrate cofhe-mock-contracts and cofhe-hardhat-plugin into @cofhe/sdk.
+
+### Patch Changes
+
+- Updated dependencies [cba73fd]
+- Updated dependencies [87fc8a0]
+- Updated dependencies [8d41cf2]
+- Updated dependencies [738b9f5]
+- Updated dependencies [a83facb]
+- Updated dependencies [9a7c98e]
+- Updated dependencies [58e93a8]
+- Updated dependencies [fdf26d4]
+- Updated dependencies [f5b8e25]
+- Updated dependencies [3b135a8]
+- Updated dependencies [5b7c43b]
+- Updated dependencies [4bc8182]
+  - @cofhe/sdk@0.1.0
+  - @cofhe/mock-contracts@0.1.0
+
+This changelog is maintained by Changesets and will be populated on each release.
+
+- Do not edit this file by hand.
+- Upcoming changes can be previewed with `pnpm changeset status --verbose`.
+- Entries are generated when the Changesets "Version Packages" PR is created/merged.

package/README.md

@@ -0,0 +1,148 @@
+# CoFHE Hardhat Plugin
+
+A Hardhat plugin for Fully Homomorphic Encryption (FHE) development with CoFHE.
+
+## Installation
+
+```bash
+npm install cofhe-hardhat-plugin
+# or
+yarn add cofhe-hardhat-plugin
+# or
+pnpm add cofhe-hardhat-plugin
+```
+
+## Configuration
+
+Add the plugin to your Hardhat config:
+
+```javascript
+// hardhat.config.js or hardhat.config.ts
+require('cofhe-hardhat-plugin');
+// or if using TypeScript
+import 'cofhe-hardhat-plugin';
+
+module.exports = {
+  // ... other config
+  cofhe: {
+    logMocks: true, // Optional: Set to true to log mock operations
+  },
+  // Network configuration is automatically added by the plugin
+};
+```
+
+The plugin automatically adds network configurations for:
+
+- Hardhat network with deployed mock contracts
+- Ethereum Sepolia testnet
+- Arbitrum Sepolia testnet
+
+## Features
+
+### Mock Contracts
+
+This plugin uses [cofhe-mock-contracts](https://github.com/FhenixProtocol/cofhe-mock-contracts) to provide on-chain simulations of the CoFHE system. These mock contracts enable development and testing without requiring the actual off-chain FHE computation engine.
+
+The mock contracts include:
+
+- MockTaskManager: Manages FHE operations and stores plaintext values
+- MockThresholdNetwork: Handles decryption requests
+- MockZkVerifier: Simulates verification of encrypted inputs
+- ACL: Handles access control
+
+Key differences from the real CoFHE system:
+
+- Operations are performed on-chain instead of off-chain
+- Plaintext values are stored on-chain for testing and verification
+- Decryption operations are simulated with mock delays
+- Operations are logged using hardhat/console.sol
+
+### Mock Contracts Deployment
+
+Mock contracts are automatically deployed when using the Hardhat network:
+
+- Running tests: `npx hardhat test`
+- Starting a local node: `npx hardhat node`
+
+To disable this automatic deployment (for example, when your tests only use external RPCs and don't need the in-process Hardhat network), set:
+
+```bash
+COFHE_SKIP_MOCKS_DEPLOY=1
+```
+
+You can also manually deploy mock contracts:
+
+```bash
+npx hardhat deploy-mocks [--deploy-test-bed true|false] [--log-mocks true|false]
+```
+
+Options:
+
+- `--deploy-test-bed`: Deploy the TestBed contract (default: true)
+- `--log-mocks`: Log mock operations (default: true)
+
+### Utility Functions
+
+The plugin exports several utility functions for working with mock contracts:
+
+#### Mock Utilities
+
+```typescript
+// Get plaintext value from a ciphertext hash
+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';
+const exists = await mock_getPlaintextExists(provider, ctHash);
+
+// Test assertion for plaintext values
+import { mock_expectPlaintext } from 'cofhe-hardhat-plugin';
+await mock_expectPlaintext(provider, ctHash, expectedValue);
+```
+
+#### Network Utilities
+
+```typescript
+// Get the CoFHE environment based on network name
+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';
+const isPermitted = isPermittedCofheEnvironment(hre, environmentName);
+
+// Initialize CoFHEjs with a Hardhat signer
+import { cofhejs_initializeWithHardhatSigner } from 'cofhe-hardhat-plugin';
+await cofhejs_initializeWithHardhatSigner(signer, options);
+```
+
+## Usage in Tests
+
+The plugin automatically deploys mock contracts when running tests:
+
+```typescript
+import { expect } from "chai";
+import { mock_expectPlaintext } from "cofhe-hardhat-plugin";
+
+describe("My FHE Contract", function() {
+  it("should store encrypted value correctly", async function() {
+    const [signer] = await ethers.getSigners();
+    const myContract = await ethers.deployContract("MyFHEContract");
+
+    // Interact with your contract
+    const tx = await myContract.storeEncrypted(123);
+    await tx.wait();
+
+    // Get the ciphertext hash from event logs
+    const ctHash = /* extract from logs */;
+
+    // Verify plaintext value (only works on hardhat network)
+    await mock_expectPlaintext(signer.provider, ctHash, 123n);
+  });
+});
+```
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,229 @@
+import { PublicClient, WalletClient } from 'viem';
+import { HardhatEthersSigner } from '@nomicfoundation/hardhat-ethers/signers';
+import { CofheInputConfig, CofheConfig, CofheClient } from '@cofhe/sdk';
+import { HardhatRuntimeEnvironment } from 'hardhat/types';
+import { MockArtifact, MockTaskManager, MockACL, MockThresholdNetwork, MockZkVerifier, TestBed } from '@cofhe/mock-contracts';
+import * as ethers from 'ethers';
+import { Contract, ethers as ethers$1 } from 'ethers';
+import { HardhatEthersProvider } from '@nomicfoundation/hardhat-ethers/internal/hardhat-ethers-provider';
+
+/**
+ * Controls deploy-mocks console output.
+ * - `''`   — silent, no output
+ * - `'v'`  — single summary line (default)
+ * - `'vv'` — full per-contract deployment logs
+ */
+type LogMocksDeploy = '' | 'v' | 'vv';
+type DeployMocksArgs = {
+    deployTestBed?: boolean;
+    gasWarning?: boolean;
+    mocksDeployVerbosity?: LogMocksDeploy;
+};
+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 | string) => Promise<any>;
+declare const mock_getPlaintextExists: (provider: HardhatEthersProvider | ethers$1.JsonRpcProvider, ctHash: bigint | string) => Promise<any>;
+declare const mock_expectPlaintext: (provider: HardhatEthersProvider | ethers$1.JsonRpcProvider, ctHash: bigint | string, expectedValue: bigint) => Promise<void>;
+
+/**
+ * Sends funds to the specified address
+ * @param hre Hardhat Runtime Environment
+ * @param toAddress Address to send funds to
+ * @param amount Amount to send in ETH (default: 10)
+ * @returns Transaction receipt or null if failed
+ */
+declare function localcofheFundAccount(hre: HardhatRuntimeEnvironment, toAddress: string, amount?: string): Promise<ethers.TransactionReceipt | null>;
+/**
+ * Checks a wallet's balance and funds it if below 1 ETH
+ * @param hre Hardhat Runtime Environment
+ * @param walletAddress Address of the wallet to check and potentially fund
+ * @returns Promise that resolves when the funding operation completes (if needed)
+ */
+declare function localcofheFundWalletIfNeeded(hre: HardhatRuntimeEnvironment, walletAddress: string): Promise<void>;
+
+declare const mock_setLoggingEnabled: (hre: HardhatRuntimeEnvironment, enabled: boolean, closureName?: string) => Promise<void>;
+declare const mock_withLogs: (hre: HardhatRuntimeEnvironment, closureName: string, closure: () => Promise<void>) => Promise<void>;
+
+/**
+ * Configuration interface for the CoFHE Hardhat plugin.
+ * Allows users to configure mock logging and gas warning settings.
+ */
+declare module 'hardhat/types/config' {
+    interface HardhatUserConfig {
+        cofhe?: {
+            /** Whether to log mock operations (default: true) */
+            logMocks?: boolean;
+            /** Whether to show gas usage warnings for mock operations (default: true) */
+            gasWarning?: boolean;
+            /**
+             * Controls deploy-mocks console output.
+             * - `''`   — silent, no output
+             * - `'v'`  — single summary line (default)
+             * - `'vv'` — full per-contract deployment logs
+             */
+            mocksDeployVerbosity?: LogMocksDeploy;
+        };
+    }
+    interface HardhatConfig {
+        cofhe: {
+            /** Whether to log mock operations (default: true) */
+            logMocks: boolean;
+            /** Whether to show gas usage warnings for mock operations (default: true) */
+            gasWarning: boolean;
+            mocksDeployVerbosity: LogMocksDeploy;
+        };
+    }
+}
+
+/**
+ * Runtime environment extensions for the CoFHE Hardhat plugin.
+ * Provides access to CoFHE initialization, environment checks, and mock utilities.
+ */
+declare module 'hardhat/types/runtime' {
+    interface HardhatRuntimeEnvironment {
+        cofhe: {
+            /**
+             * Create a CoFHE configuration for use with hre.cofhe.createClient(...)
+             * @param {CofheInputConfig} config - The CoFHE input configuration
+             * @returns {CofheConfig} The CoFHE configuration
+             */
+            createConfig: (config: CofheInputConfig) => Promise<CofheConfig>;
+            /**
+             * Create a CoFHE client instance
+             * @param {CofheConfig} config - The CoFHE configuration (use createCofheConfig to create with Node.js defaults)
+             * @returns {Promise<CofheClient>} The CoFHE client instance
+             */
+            createClient: (config: CofheConfig) => CofheClient;
+            /**
+             * Create viem clients from a Hardhat ethers signer, to be used with `cofheClient.connect(...)`
+             * @param {HardhatEthersSigner} signer - The Hardhat ethers signer to use
+             * @returns {Promise<{ publicClient: PublicClient; walletClient: WalletClient }>} The viem clients
+             */
+            hardhatSignerAdapter: (signer: HardhatEthersSigner) => Promise<{
+                publicClient: PublicClient;
+                walletClient: WalletClient;
+            }>;
+            /**
+             * Connect a CoFHE client with a Hardhat ethers signer
+             * @param {CofheClient} client - The CoFHE client to connect
+             * @param {HardhatEthersSigner} signer - The Hardhat ethers signer to use
+             * @returns {Promise<void>}
+             */
+            connectWithHardhatSigner: (client: CofheClient, signer: HardhatEthersSigner) => Promise<void>;
+            /**
+             * Create and connect to a batteries included client.
+             * Also generates a self-usage a permit for the signer.
+             * If customization is needed, use createCofheClient and connectWithHardhatSigner.
+             * @param {HardhatEthersSigner} signer - The Hardhat ethers signer to use (optional - defaults to first signer)
+             * @returns {Promise<CofheClient>} The CoFHE client instance
+             */
+            createClientWithBatteries: (signer?: HardhatEthersSigner) => Promise<CofheClient>;
+            mocks: {
+                /**
+                 * **[MOCKS ONLY]**
+                 *
+                 * Execute a block of code with cofhe mock contracts logging enabled.
+                 *
+                 * _(If logging only a function, we recommend passing the function name as the closureName (ex "counter.increment()"))_
+                 *
+                 * Example usage:
+                 *
+                 * ```ts
+                 * await hre.cofhe.mocks.withLogs("counter.increment()", async () => {
+                 *   await counter.increment();
+                 * });
+                 * ```
+                 *
+                 * Expected output:
+                 * ```
+                 * ┌──────────────────┬──────────────────────────────────────────────────
+                 * │ [COFHE-MOCKS]    │ "counter.increment()" logs:
+                 * ├──────────────────┴──────────────────────────────────────────────────
+                 * ├ FHE.add          | euint32(4473..3424)[0] + euint32(1157..3648)[1]  =>  euint32(1106..1872)[1]
+                 * ├ FHE.allowThis    | euint32(1106..1872)[1] -> 0x663f..6602
+                 * ├ FHE.allow        | euint32(1106..1872)[1] -> 0x3c44..93bc
+                 * └─────────────────────────────────────────────────────────────────────
+                 * ```
+                 * @param {string} closureName - Name of the code block to log within
+                 * @param {() => Promise<void>} closure - The async function to execute
+                 */
+                withLogs: (closureName: string, closure: () => Promise<void>) => Promise<void>;
+                /**
+                 * **[MOCKS ONLY]**
+                 *
+                 * Enable logging from cofhe mock contracts
+                 * @param {string} closureName - Optional name of the code block to enable logging for
+                 */
+                enableLogs: (closureName?: string) => Promise<void>;
+                /**
+                 * **[MOCKS ONLY]**
+                 *
+                 * Disable logging from cofhe mock contracts
+                 */
+                disableLogs: () => Promise<void>;
+                /**
+                 * **[MOCKS ONLY]**
+                 *
+                 * Deploy the cofhe mock contracts (normally this is done automatically)
+                 * @param {DeployMocksArgs} options - Deployment options
+                 */
+                deployMocks: (options?: DeployMocksArgs) => Promise<void>;
+                /**
+                 * **[MOCKS ONLY]**
+                 *
+                 * Get the plaintext value for a ciphertext hash
+                 * @param {bigint | string} ctHash - The ciphertext hash to look up
+                 * @returns {Promise<bigint>} The plaintext value
+                 */
+                getPlaintext: (ctHash: bigint | string) => Promise<bigint>;
+                /**
+                 * **[MOCKS ONLY]**
+                 *
+                 * Assert that a ciphertext hash represents an expected plaintext value
+                 * @param {bigint | string} ctHash - The ciphertext hash to check
+                 * @param {bigint} expectedValue - The expected plaintext value
+                 */
+                expectPlaintext: (ctHash: bigint | string, expectedValue: bigint) => Promise<void>;
+                /**
+                 * Get the MockTaskManager contract (typed via typechain)
+                 * @returns {Promise<MockTaskManager>} The MockTaskManager contract
+                 */
+                getMockTaskManager: () => Promise<MockTaskManager>;
+                /**
+                 * Get the MockACL contract (typed via typechain)
+                 * @returns {Promise<MockACL>} The MockACL contract
+                 */
+                getMockACL: () => Promise<MockACL>;
+                /**
+                 * Get the MockThresholdNetwork contract (typed via typechain)
+                 * @returns {Promise<MockThresholdNetwork>} The MockThresholdNetwork contract
+                 */
+                getMockThresholdNetwork: () => Promise<MockThresholdNetwork>;
+                /**
+                 * Get the MockZkVerifier contract (typed via typechain)
+                 * @returns {Promise<MockZkVerifier>} The MockZkVerifier contract
+                 */
+                getMockZkVerifier: () => Promise<MockZkVerifier>;
+                /**
+                 * Get the TestBed contract (typed via typechain)
+                 * @returns {Promise<TestBed>} The TestBed contract
+                 */
+                getTestBed: () => Promise<TestBed>;
+            };
+        };
+    }
+}
+/**
+ * Builds the mocks config for the hardhat plugin.
+ * Defaults `encryptDelay` to `0` so tests run without artificial wait times,
+ * unless the user has explicitly provided a value.
+ */
+declare function buildHardhatPluginMocksConfig(mocksConfig: CofheInputConfig['mocks']): NonNullable<CofheInputConfig['mocks']>;
+
+export { type DeployMocksArgs, type LogMocksDeploy, TASK_COFHE_MOCKS_DEPLOY, TASK_COFHE_MOCKS_SET_LOG_OPS, TASK_COFHE_USE_FAUCET, buildHardhatPluginMocksConfig, deployMockContractFromArtifact, deployMocks, getFixedMockContract, localcofheFundAccount, localcofheFundWalletIfNeeded, mock_expectPlaintext, mock_getPlaintext, mock_getPlaintextExists, mock_setLoggingEnabled, mock_withLogs };