@cofhe/hardhat-3-plugin 0.0.0-alpha-20260409113701

package/src/type-extensions.ts

@@ -0,0 +1,107 @@
+import type { WalletClient } from 'viem';
+import type { CofheClient, CofheConfig, CofheInputConfig } from '@cofhe/sdk';
+import type { DeployMocksArgs, LogMocksDeploy } from './deploy.js';
+import type {
+  MockTaskManagerArtifact,
+  MockACLArtifact,
+  MockZkVerifierArtifact,
+  MockThresholdNetworkArtifact,
+  TestBedArtifact,
+} from '@cofhe/mock-contracts';
+
+import 'hardhat/types/network';
+
+// ─── Per-connection CoFHE API ─────────────────────────────────────────────────
+
+export interface CofheConnection {
+  /**
+   * Create a CoFHE configuration. Defaults to hardhat environment;
+   * pass overrides as needed.
+   */
+  createConfig(config?: Partial<CofheInputConfig>): Promise<CofheConfig>;
+
+  /** Create a CoFHE client instance from a config. */
+  createClient(config: CofheConfig): CofheClient;
+
+  /**
+   * Create and connect a batteries-included CoFHE client.
+   * If a WalletClient is provided it is used as the signer; otherwise the
+   * first account from the connection is used automatically.
+   */
+  createClientWithBatteries(walletClient?: WalletClient): Promise<CofheClient>;
+
+  mocks: {
+    /** Deploy (or re-deploy) the mock contracts. */
+    deployMocks(options?: DeployMocksArgs): Promise<void>;
+
+    /** Execute a block with CoFHE mock logging enabled. */
+    withLogs(closureName: string, closure: () => Promise<void>): Promise<void>;
+
+    /** Enable logging from CoFHE mock contracts. */
+    enableLogs(closureName?: string): Promise<void>;
+
+    /** Disable logging from CoFHE mock contracts. */
+    disableLogs(): Promise<void>;
+
+    /** Get the plaintext value stored for a ciphertext hash. */
+    getPlaintext(ctHash: bigint | string): Promise<bigint>;
+
+    /** Assert that a ciphertext hash represents the expected plaintext value. */
+    expectPlaintext(ctHash: bigint | string, expectedValue: bigint): Promise<void>;
+
+    /** MockTaskManager contract descriptor — spread into readContract / writeContract */
+    MockTaskManager: { address: `0x${string}`; abi: typeof MockTaskManagerArtifact.abi };
+
+    /** Resolves the MockACL descriptor from the TaskManager on-chain. */
+    MockACL(): Promise<{ address: `0x${string}`; abi: typeof MockACLArtifact.abi }>;
+
+    /** MockZkVerifier contract descriptor */
+    MockZkVerifier: { address: `0x${string}`; abi: typeof MockZkVerifierArtifact.abi };
+
+    /** MockThresholdNetwork contract descriptor */
+    MockThresholdNetwork: { address: `0x${string}`; abi: typeof MockThresholdNetworkArtifact.abi };
+
+    /** TestBed contract descriptor */
+    TestBed: { address: `0x${string}`; abi: typeof TestBedArtifact.abi };
+  };
+}
+
+// ─── Hardhat config augmentation ─────────────────────────────────────────────
+
+declare module 'hardhat/types/config' {
+  interface HardhatUserConfig {
+    cofhe?: {
+      /** Whether to log mock FHE 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: {
+      logMocks: boolean;
+      gasWarning: boolean;
+      mocksDeployVerbosity: LogMocksDeploy;
+    };
+  }
+}
+
+// ─── NetworkConnection augmentation ──────────────────────────────────────────
+
+declare module 'hardhat/types/network' {
+  interface NetworkConnection {
+    /**
+     * CoFHE mock environment — ready to use immediately after network.connect().
+     * Mock contracts are deployed automatically on every connect().
+     */
+    cofhe: CofheConnection;
+  }
+}

package/src/utils.ts

@@ -0,0 +1,79 @@
+import type { PublicClient } from 'viem';
+import { TASK_MANAGER_ADDRESS, MOCKS_ZK_VERIFIER_ADDRESS } from '@cofhe/sdk';
+
+// ─── Mock storage helpers ─────────────────────────────────────────────────────
+
+/**
+ * Returns true when mock contracts are deployed (ZkVerifier has code).
+ */
+async function isMockEnvironment(publicClient: PublicClient): Promise<boolean> {
+  const bytecode = await publicClient.getCode({
+    address: MOCKS_ZK_VERIFIER_ADDRESS,
+  });
+  return !!bytecode && bytecode.length > 2;
+}
+
+/**
+ * Reads the plaintext value stored for a ciphertext hash from MockTaskManager.
+ * Returns undefined when not running on a mock network.
+ */
+export async function mock_getPlaintext(
+  publicClient: PublicClient,
+  ctHash: bigint | string
+): Promise<bigint | undefined> {
+  if (!(await isMockEnvironment(publicClient))) {
+    console.log('mock_getPlaintext — skipped on non-mock network');
+    return undefined;
+  }
+
+  return publicClient.readContract({
+    address: TASK_MANAGER_ADDRESS,
+    abi: [
+      {
+        name: 'mockStorage',
+        type: 'function',
+        inputs: [{ name: 'ctHash', type: 'uint256' }],
+        outputs: [{ type: 'uint256' }],
+        stateMutability: 'view',
+      },
+    ],
+    functionName: 'mockStorage',
+    args: [BigInt(ctHash)],
+  }) as Promise<bigint>;
+}
+
+/**
+ * Asserts that a ciphertext hash maps to the expected plaintext value.
+ */
+export async function mock_expectPlaintext(
+  publicClient: PublicClient,
+  ctHash: bigint | string,
+  expectedValue: bigint
+): Promise<void> {
+  if (!(await isMockEnvironment(publicClient))) {
+    console.log('mock_expectPlaintext — skipped on non-mock network');
+    return;
+  }
+
+  const exists = (await publicClient.readContract({
+    address: TASK_MANAGER_ADDRESS,
+    abi: [
+      {
+        name: 'inMockStorage',
+        type: 'function',
+        inputs: [{ name: 'ctHash', type: 'uint256' }],
+        outputs: [{ type: 'bool' }],
+        stateMutability: 'view',
+      },
+    ],
+    functionName: 'inMockStorage',
+    args: [BigInt(ctHash)],
+  })) as boolean;
+
+  if (!exists) throw new Error(`mock_expectPlaintext: ctHash ${ctHash} not found in mock storage`);
+
+  const plaintext = await mock_getPlaintext(publicClient, ctHash);
+  if (plaintext !== expectedValue) {
+    throw new Error(`mock_expectPlaintext: expected ${expectedValue}, got ${plaintext} for ctHash ${ctHash}`);
+  }
+}