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

package/dist/hre-YCSQIPJL.js

@@ -0,0 +1,143 @@
+import {
+  deployMocks,
+  mock_expectPlaintext,
+  mock_getPlaintext
+} from "./chunk-5FCSZD6A.js";
+import {
+  mock_setLoggingEnabled,
+  mock_withLogs
+} from "./chunk-IVRNGFNF.js";
+
+// src/hooks/hre.ts
+import { createPublicClient, createWalletClient, custom } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import {
+  MockTaskManagerArtifact,
+  MockACLArtifact,
+  MockZkVerifierArtifact,
+  MockThresholdNetworkArtifact,
+  TestBedArtifact
+} from "@cofhe/mock-contracts";
+import { MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY } from "@cofhe/sdk";
+import { createCofheConfig, createCofheClient } from "@cofhe/sdk/node";
+import { hardhat as hardhatChain } from "@cofhe/sdk/chains";
+function createCofheConnection(publicClient, walletClient, transport) {
+  return {
+    async createConfig(config = {}) {
+      const zkvAccount = privateKeyToAccount(MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY);
+      const zkvWalletClient = createWalletClient({ account: zkvAccount, transport });
+      return createCofheConfig({
+        environment: "hardhat",
+        supportedChains: [hardhatChain],
+        ...config,
+        mocks: {
+          encryptDelay: 0,
+          ...config.mocks
+        },
+        _internal: {
+          ...config._internal,
+          zkvWalletClient
+        }
+      });
+    },
+    createClient(config) {
+      return createCofheClient(config);
+    },
+    async createClientWithBatteries(signerWalletClient) {
+      let signerClient;
+      let address;
+      if (signerWalletClient) {
+        const [addr] = await signerWalletClient.getAddresses();
+        if (!addr) throw new Error("createClientWithBatteries: provided walletClient has no accounts");
+        signerClient = signerWalletClient;
+        address = addr;
+      } else {
+        const [addr] = await walletClient.getAddresses();
+        if (!addr) throw new Error("createClientWithBatteries: no accounts available on this connection");
+        address = addr;
+        signerClient = createWalletClient({ account: address, transport });
+      }
+      const config = await this.createConfig();
+      const client = this.createClient(config);
+      await client.connect(publicClient, signerClient);
+      await client.permits.createSelf({ issuer: address });
+      return client;
+    },
+    mocks: {
+      async deployMocks(options) {
+        await deployMocks({ publicClient, walletClient }, options);
+      },
+      async withLogs(closureName, closure) {
+        await mock_withLogs(publicClient, walletClient, closureName, closure);
+      },
+      async enableLogs(closureName) {
+        await mock_setLoggingEnabled(publicClient, walletClient, true, closureName);
+      },
+      async disableLogs() {
+        await mock_setLoggingEnabled(publicClient, walletClient, false);
+      },
+      async getPlaintext(ctHash) {
+        const value = await mock_getPlaintext(publicClient, ctHash);
+        if (value === void 0) throw new Error("getPlaintext: not on mock network");
+        return value;
+      },
+      async expectPlaintext(ctHash, expectedValue) {
+        await mock_expectPlaintext(publicClient, ctHash, expectedValue);
+      },
+      MockTaskManager: {
+        address: MockTaskManagerArtifact.fixedAddress,
+        abi: MockTaskManagerArtifact.abi
+      },
+      async MockACL() {
+        const address = await publicClient.readContract({
+          address: MockTaskManagerArtifact.fixedAddress,
+          abi: [
+            { name: "acl", type: "function", inputs: [], outputs: [{ type: "address" }], stateMutability: "view" }
+          ],
+          functionName: "acl"
+        });
+        return { address, abi: MockACLArtifact.abi };
+      },
+      MockZkVerifier: {
+        address: MockZkVerifierArtifact.fixedAddress,
+        abi: MockZkVerifierArtifact.abi
+      },
+      MockThresholdNetwork: {
+        address: MockThresholdNetworkArtifact.fixedAddress,
+        abi: MockThresholdNetworkArtifact.abi
+      },
+      TestBed: {
+        address: TestBedArtifact.fixedAddress,
+        abi: TestBedArtifact.abi
+      }
+    }
+  };
+}
+var hreHooks = {
+  async created(_context, hre) {
+    const networkHandlers = {
+      async newConnection(context, next) {
+        const conn = await next(context);
+        const transport = custom(conn.provider);
+        const publicClient = createPublicClient({ transport });
+        const walletClient = createWalletClient({ transport });
+        const connTransport = custom({ request: (args) => walletClient.request(args) });
+        await deployMocks(
+          { publicClient, walletClient },
+          {
+            deployTestBed: true,
+            gasWarning: hre.config.cofhe.gasWarning,
+            mocksDeployVerbosity: hre.config.cofhe.mocksDeployVerbosity
+          }
+        );
+        conn.cofhe = createCofheConnection(publicClient, walletClient, connTransport);
+        return conn;
+      }
+    };
+    hre.hooks.registerHandlers("network", networkHandlers);
+  }
+};
+var hre_default = async () => hreHooks;
+export {
+  hre_default as default
+};

package/dist/index.d.ts

@@ -0,0 +1,140 @@
+import { HardhatPlugin } from 'hardhat/types/plugins';
+import { PublicClient, WalletClient } from 'viem';
+import { CofheInputConfig, CofheConfig, CofheClient } from '@cofhe/sdk';
+import { MockTaskManagerArtifact, MockACLArtifact, MockZkVerifierArtifact, MockThresholdNetworkArtifact, TestBedArtifact } from '@cofhe/mock-contracts';
+
+/**
+ * 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;
+};
+type DeployContext = {
+    publicClient: PublicClient;
+    walletClient: WalletClient;
+};
+declare function deployMocks(ctx: DeployContext, options?: DeployMocksArgs): Promise<void>;
+
+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;
+        };
+    };
+}
+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;
+        };
+    }
+}
+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;
+    }
+}
+
+declare const TASK_COFHE_USE_FAUCET = "cofhe:faucet";
+declare const TASK_COFHE_SET_LOG_OPS = "cofhe:set-log-ops";
+
+/**
+ * Sends ETH to `toAddress` on the localcofhe network using the funder wallet.
+ * The funder private key can be overridden via the FUNDER_PRIVATE_KEY environment variable.
+ */
+declare function localcofheFundAccount(publicClient: PublicClient, walletClient: WalletClient, toAddress: `0x${string}`, amount?: string): Promise<void>;
+/**
+ * Checks a wallet's balance and funds it if below 1 ETH.
+ */
+declare function localcofheFundWalletIfNeeded(publicClient: PublicClient, walletClient: WalletClient, walletAddress: `0x${string}`): Promise<void>;
+
+declare function mock_setLoggingEnabled(publicClient: PublicClient, walletClient: WalletClient, enabled: boolean, closureName?: string): Promise<void>;
+declare function mock_withLogs(publicClient: PublicClient, walletClient: WalletClient, closureName: string, closure: () => Promise<void>): Promise<void>;
+
+/**
+ * Reads the plaintext value stored for a ciphertext hash from MockTaskManager.
+ * Returns undefined when not running on a mock network.
+ */
+declare function mock_getPlaintext(publicClient: PublicClient, ctHash: bigint | string): Promise<bigint | undefined>;
+/**
+ * Asserts that a ciphertext hash maps to the expected plaintext value.
+ */
+declare function mock_expectPlaintext(publicClient: PublicClient, ctHash: bigint | string, expectedValue: bigint): Promise<void>;
+
+declare const plugin: HardhatPlugin;
+
+export { type DeployContext, type DeployMocksArgs, type LogMocksDeploy, TASK_COFHE_SET_LOG_OPS, TASK_COFHE_USE_FAUCET, plugin as default, deployMocks, localcofheFundAccount, localcofheFundWalletIfNeeded, mock_expectPlaintext, mock_getPlaintext, mock_setLoggingEnabled, mock_withLogs };

package/dist/index.js

@@ -0,0 +1,52 @@
+import {
+  deployMocks,
+  mock_expectPlaintext,
+  mock_getPlaintext
+} from "./chunk-5FCSZD6A.js";
+import {
+  localcofheFundAccount,
+  localcofheFundWalletIfNeeded
+} from "./chunk-Z2FAJP4Y.js";
+import {
+  mock_setLoggingEnabled,
+  mock_withLogs
+} from "./chunk-IVRNGFNF.js";
+
+// src/index.ts
+import { task } from "hardhat/config";
+import { ArgumentType } from "hardhat/types/arguments";
+
+// src/consts.ts
+var TASK_COFHE_USE_FAUCET = "cofhe:faucet";
+var TASK_COFHE_SET_LOG_OPS = "cofhe:set-log-ops";
+
+// src/index.ts
+var plugin = {
+  id: "@cofhe/hardhat-3-plugin",
+  hookHandlers: {
+    config: async () => import("./config-YK3LB5IH.js"),
+    hre: async () => import("./hre-YCSQIPJL.js")
+  },
+  tasks: [
+    task(TASK_COFHE_USE_FAUCET, "Fund an account via the localcofhe faucet").addOption({
+      name: "address",
+      description: "Address to fund",
+      type: ArgumentType.STRING_WITHOUT_DEFAULT,
+      defaultValue: void 0
+    }).setAction(async () => import("./use-faucet-O732FNWJ.js")).build(),
+    task(TASK_COFHE_SET_LOG_OPS, "Enable or disable CoFHE mock contract logging").addFlag({ name: "enable", description: "Whether to enable logging" }).setAction(async () => import("./set-log-ops-GVEQWMZP.js")).build()
+  ]
+};
+var index_default = plugin;
+export {
+  TASK_COFHE_SET_LOG_OPS,
+  TASK_COFHE_USE_FAUCET,
+  index_default as default,
+  deployMocks,
+  localcofheFundAccount,
+  localcofheFundWalletIfNeeded,
+  mock_expectPlaintext,
+  mock_getPlaintext,
+  mock_setLoggingEnabled,
+  mock_withLogs
+};

package/dist/set-log-ops-GVEQWMZP.js

@@ -0,0 +1,15 @@
+import {
+  mock_setLoggingEnabled
+} from "./chunk-IVRNGFNF.js";
+
+// src/tasks/set-log-ops.ts
+import { createPublicClient, createWalletClient, custom } from "viem";
+var action = async ({ enable }, hre) => {
+  const connection = await hre.network.connect();
+  const transport = custom(connection.provider);
+  await mock_setLoggingEnabled(createPublicClient({ transport }), createWalletClient({ transport }), enable);
+};
+var set_log_ops_default = action;
+export {
+  set_log_ops_default as default
+};

package/dist/use-faucet-O732FNWJ.js

@@ -0,0 +1,33 @@
+import {
+  localcofheFundAccount
+} from "./chunk-Z2FAJP4Y.js";
+
+// src/tasks/use-faucet.ts
+import { createPublicClient, createWalletClient, custom } from "viem";
+import chalk from "chalk";
+var action = async ({ address }, hre) => {
+  const connection = await hre.network.connect();
+  if (connection.networkName !== "localcofhe") {
+    console.info(chalk.yellow("Programmatic faucet only supported for localcofhe"));
+    return;
+  }
+  if (!address) {
+    console.info(chalk.red("Failed to get address to fund"));
+    return;
+  }
+  console.info(chalk.green(`Getting funds from faucet for ${address}`));
+  const transport = custom(connection.provider);
+  try {
+    await localcofheFundAccount(
+      createPublicClient({ transport }),
+      createWalletClient({ transport }),
+      address
+    );
+  } catch (e) {
+    console.info(chalk.red(`Failed to get funds from localcofhe for ${address}: ${e}`));
+  }
+};
+var use_faucet_default = action;
+export {
+  use_faucet_default as default
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@cofhe/hardhat-3-plugin",
+  "version": "0.0.0-alpha-20260409113701",
+  "description": "Hardhat 3 plugin for CoFHE — deploys mock contracts and wires up the hre.cofhe interface",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "sideEffects": false,
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/FhenixProtocol/cofhesdk.git",
+    "directory": "packages/hardhat-3-plugin"
+  },
+  "files": [
+    "dist/**",
+    "src/**",
+    "CHANGELOG.md",
+    "README.md"
+  ],
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "viem": "^2.38.6",
+    "@cofhe/mock-contracts": "0.0.0-alpha-20260409113701",
+    "@cofhe/sdk": "0.0.0-alpha-20260409113701"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "hardhat": "^3.1.12",
+    "tsup": "^8.0.2",
+    "typescript": "5.5.4",
+    "@cofhe/tsconfig": "0.1.2"
+  },
+  "peerDependencies": {
+    "hardhat": "^3.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts",
+    "dev": "tsup src/index.ts --format esm --dts --watch",
+    "check:types": "tsc --noEmit",
+    "clean": "rm -rf dist node_modules .tsbuildinfo"
+  }
+}

package/src/config.ts

@@ -0,0 +1,64 @@
+import type { HardhatUserConfig, HardhatConfig } from 'hardhat/types/config';
+import type { LogMocksDeploy } from './deploy.js';
+
+/**
+ * Extends the resolved config with plugin defaults and network presets.
+ * Mirrors the logic from the v2 plugin's extendConfig callback.
+ */
+export function resolvePluginConfig(userConfig: HardhatUserConfig, resolvedConfig: HardhatConfig): void {
+  // Inject localcofhe network preset if the user hasn't defined it
+  if (!userConfig.networks?.['localcofhe']) {
+    (resolvedConfig.networks as Record<string, unknown>)['localcofhe'] = {
+      type: 'http',
+      url: 'http://127.0.0.1:42069',
+      gas: 'auto',
+      gasMultiplier: 1.2,
+      gasPrice: 'auto',
+      timeout: 10_000,
+      httpHeaders: {},
+      accounts: [
+        '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
+        '0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d',
+        '0x5de4111afa1a4b94908f83103eb1f1706367c2e68ca870fc3fb9a804cdab365a',
+        '0x7c852118294e51e653712a81e05800f419141751be58f605c371e15141b007a6',
+      ],
+    };
+  }
+
+  // Inject eth-sepolia preset if the user hasn't defined it
+  if (!userConfig.networks?.['eth-sepolia']) {
+    (resolvedConfig.networks as Record<string, unknown>)['eth-sepolia'] = {
+      type: 'http',
+      url: process.env['SEPOLIA_RPC_URL'] ?? 'https://ethereum-sepolia.publicnode.com',
+      accounts: process.env['PRIVATE_KEY'] ? [process.env['PRIVATE_KEY']] : [],
+      chainId: 11155111,
+      gas: 'auto',
+      gasMultiplier: 1.2,
+      gasPrice: 'auto',
+      timeout: 60_000,
+      httpHeaders: {},
+    };
+  }
+
+  // Inject arb-sepolia preset if the user hasn't defined it
+  if (!userConfig.networks?.['arb-sepolia']) {
+    (resolvedConfig.networks as Record<string, unknown>)['arb-sepolia'] = {
+      type: 'http',
+      url: process.env['ARBITRUM_SEPOLIA_RPC_URL'] ?? 'https://sepolia-rollup.arbitrum.io/rpc',
+      accounts: process.env['PRIVATE_KEY'] ? [process.env['PRIVATE_KEY']] : [],
+      chainId: 421614,
+      gas: 'auto',
+      gasMultiplier: 1.2,
+      gasPrice: 'auto',
+      timeout: 60_000,
+      httpHeaders: {},
+    };
+  }
+
+  // Resolve cofhe plugin config
+  resolvedConfig.cofhe = {
+    logMocks: userConfig.cofhe?.logMocks ?? false,
+    gasWarning: userConfig.cofhe?.gasWarning ?? false,
+    mocksDeployVerbosity: (userConfig.cofhe?.mocksDeployVerbosity ?? 'v') as LogMocksDeploy,
+  };
+}

package/src/consts.ts

@@ -0,0 +1,2 @@
+export const TASK_COFHE_USE_FAUCET = 'cofhe:faucet';
+export const TASK_COFHE_SET_LOG_OPS = 'cofhe:set-log-ops';