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

package/src/deploy.ts

@@ -0,0 +1,250 @@
+import type { PublicClient, WalletClient } from 'viem';
+import { createTestClient, custom } from 'viem';
+import chalk from 'chalk';
+import { privateKeyToAccount } from 'viem/accounts';
+
+import {
+  MockTaskManagerArtifact,
+  MockACLArtifact,
+  MockZkVerifierArtifact,
+  MockThresholdNetworkArtifact,
+  TestBedArtifact,
+} from '@cofhe/mock-contracts';
+import {
+  TASK_MANAGER_ADDRESS,
+  MOCKS_ZK_VERIFIER_ADDRESS,
+  MOCKS_ZK_VERIFIER_SIGNER_ADDRESS,
+  MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY,
+  MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY,
+} from '@cofhe/sdk';
+
+/**
+ * Controls deploy-mocks console output.
+ * - `''`   — silent, no output
+ * - `'v'`  — single summary line (default)
+ * - `'vv'` — full per-contract deployment logs
+ */
+export type LogMocksDeploy = '' | 'v' | 'vv';
+
+export type DeployMocksArgs = {
+  deployTestBed?: boolean;
+  gasWarning?: boolean;
+  mocksDeployVerbosity?: LogMocksDeploy;
+};
+
+export type DeployContext = {
+  publicClient: PublicClient;
+  walletClient: WalletClient;
+};
+
+let verbosity: LogMocksDeploy = 'v';
+
+// ─── Public entrypoint ────────────────────────────────────────────────────────
+
+/**
+ * Returns true when the provider supports Hardhat-specific RPC methods (i.e.
+ * it is an in-process Hardhat / EDR network, or localcofhe).
+ */
+async function isLocalHardhatNetwork(publicClient: PublicClient): Promise<boolean> {
+  try {
+    await (publicClient as any).request({ method: 'hardhat_metadata', params: [] });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function deployMocks(ctx: DeployContext, options: DeployMocksArgs = {}): Promise<void> {
+  const { deployTestBed = true, gasWarning = true } = options;
+  verbosity = options.mocksDeployVerbosity ?? 'v';
+
+  if (!(await isLocalHardhatNetwork(ctx.publicClient))) {
+    log('v', `cofhe-hardhat-3-plugin - deploy mocks - skipped on non-hardhat network`, 0);
+    return;
+  }
+
+  log('vv', chalk.bold('cofhe-hardhat-3-plugin :: deploy mocks'), 0);
+
+  // 1. Deploy TaskManager to its fixed address
+  await deployFixed(ctx.publicClient, MockTaskManagerArtifact);
+  logDeployment('MockTaskManager', TASK_MANAGER_ADDRESS);
+
+  // 2. Initialize TaskManager — owner = first connected account
+  const [account] = await ctx.walletClient.getAddresses();
+  await ctx.walletClient.writeContract({
+    address: TASK_MANAGER_ADDRESS,
+    abi: MockTaskManagerArtifact.abi,
+    functionName: 'initialize',
+    args: [account],
+    account,
+    chain: null,
+  });
+
+  // 3. Configure security zones
+  await ctx.walletClient.writeContract({
+    address: TASK_MANAGER_ADDRESS,
+    abi: MockTaskManagerArtifact.abi,
+    functionName: 'setSecurityZones',
+    args: [0, 1],
+    account,
+    chain: null,
+  });
+
+  // 4. Deploy MockACL normally so its EIP-712 constructor runs
+  const aclAddress = await deployVariable(ctx, MockACLArtifact, []);
+  logDeployment('MockACL', aclAddress);
+
+  // 5. Link ACL into TaskManager
+  await ctx.walletClient.writeContract({
+    address: TASK_MANAGER_ADDRESS,
+    abi: MockTaskManagerArtifact.abi,
+    functionName: 'setACLContract',
+    args: [aclAddress],
+    account,
+    chain: null,
+  });
+  log('vv', 'ACL address set in TaskManager', 2);
+
+  // 6. Set ZkVerifier signer (the key is well-known and shared with the SDK)
+  const verifierSigner = privateKeyToAccount(MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY);
+  await ctx.walletClient.writeContract({
+    address: TASK_MANAGER_ADDRESS,
+    abi: MockTaskManagerArtifact.abi,
+    functionName: 'setVerifierSigner',
+    args: [verifierSigner.address],
+    account,
+    chain: null,
+  });
+  log('vv', 'Verifier signer set', 2);
+
+  // 7. Set decrypt result signer
+  const decryptSigner = privateKeyToAccount(MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY);
+  await ctx.walletClient.writeContract({
+    address: TASK_MANAGER_ADDRESS,
+    abi: MockTaskManagerArtifact.abi,
+    functionName: 'setDecryptResultSigner',
+    args: [decryptSigner.address],
+    account,
+    chain: null,
+  });
+  log('vv', 'Decrypt result signer set', 2);
+
+  // 8. Fund the ZkVerifier signer account so it can send transactions.
+  //    We create a testClient on-the-fly from the publicClient's transport.
+  const testClient = createTestClient({
+    mode: 'hardhat',
+    transport: custom(ctx.publicClient.transport as any),
+  });
+  await testClient.setBalance({
+    address: MOCKS_ZK_VERIFIER_SIGNER_ADDRESS,
+    value: BigInt('10000000000000000000'), // 10 ETH
+  });
+  log('vv', `ZkVerifier signer (${MOCKS_ZK_VERIFIER_SIGNER_ADDRESS}) funded`, 1);
+
+  const zkVerifierBalance = await ctx.publicClient.getBalance({ address: MOCKS_ZK_VERIFIER_SIGNER_ADDRESS });
+  log('vv', `ETH balance: ${zkVerifierBalance.toString()}`, 2);
+
+  // 9. Deploy MockZkVerifier to its fixed address
+  await deployFixed(ctx.publicClient, MockZkVerifierArtifact);
+  logDeployment('MockZkVerifier', MOCKS_ZK_VERIFIER_ADDRESS);
+
+  // 10. Deploy MockThresholdNetwork to its fixed address + initialize
+  await deployFixed(ctx.publicClient, MockThresholdNetworkArtifact);
+  logDeployment('MockThresholdNetwork', MockThresholdNetworkArtifact.fixedAddress);
+  await ctx.walletClient.writeContract({
+    address: MockThresholdNetworkArtifact.fixedAddress as `0x${string}`,
+    abi: MockThresholdNetworkArtifact.abi,
+    functionName: 'initialize',
+    args: [TASK_MANAGER_ADDRESS, aclAddress],
+    account,
+    chain: null,
+  });
+
+  // 11. Optionally deploy TestBed
+  if (deployTestBed) {
+    await deployFixed(ctx.publicClient, TestBedArtifact);
+    logDeployment('TestBed', TestBedArtifact.fixedAddress);
+  }
+
+  log('v', chalk.bold('cofhe-hardhat-3-plugin :: mocks deployed'), 0);
+
+  if (gasWarning) {
+    logEmpty('v');
+    logWarning(
+      'When using mocks, FHE operations report a higher gas price due to on-chain mocking logic. ' +
+        'Deploy your contracts on a testnet to check true gas costs.\n' +
+        "(Disable this warning by setting 'cofhe.gasWarning: false' in your Hardhat config)",
+      0
+    );
+  }
+
+  logEmpty('v');
+}
+
+// ─── Deployment helpers ───────────────────────────────────────────────────────
+
+/** Sets code at a fixed address via hardhat_setCode. */
+async function deployFixed(
+  publicClient: PublicClient,
+  artifact: { fixedAddress: string; deployedBytecode: string }
+): Promise<void> {
+  await (publicClient as any).request({
+    method: 'hardhat_setCode',
+    params: [artifact.fixedAddress, artifact.deployedBytecode],
+  });
+}
+
+/** Deploys a variable-address artifact and returns the deployed address. */
+async function deployVariable(
+  ctx: DeployContext,
+  artifact: { abi: readonly unknown[]; bytecode: string },
+  constructorArgs: readonly unknown[]
+): Promise<`0x${string}`> {
+  const [account] = await ctx.walletClient.getAddresses();
+
+  const hash = await ctx.walletClient.deployContract({
+    abi: artifact.abi,
+    bytecode: artifact.bytecode as `0x${string}`,
+    args: constructorArgs,
+    account,
+    chain: null,
+  });
+
+  const receipt = await ctx.publicClient.waitForTransactionReceipt({ hash });
+
+  if (!receipt.contractAddress) {
+    throw new Error('deployVariable: no contractAddress in receipt');
+  }
+
+  return receipt.contractAddress;
+}
+
+// ─── Logging ──────────────────────────────────────────────────────────────────
+
+/**
+ * Emit a green ✓ line at `minVerbosity` or above.
+ * - `minVerbosity = 'v'`  → prints for both 'v' and 'vv'
+ * - `minVerbosity = 'vv'` → prints only for 'vv'
+ */
+const log = (minVerbosity: 'v' | 'vv', message: string, indent = 1) => {
+  if (verbosity === '') return;
+  if (minVerbosity === 'vv' && verbosity !== 'vv') return;
+  console.log(chalk.green(`${'  '.repeat(indent)}✓ ${message}`));
+};
+
+const logEmpty = (minVerbosity: 'v' | 'vv' = 'v') => {
+  if (verbosity === '') return;
+  if (minVerbosity === 'vv' && verbosity !== 'vv') return;
+  console.log('');
+};
+
+const logWarning = (message: string, indent = 1) => {
+  if (verbosity === '') return;
+  console.log(chalk.bold(chalk.yellow(`${'  '.repeat(indent)}⚠ NOTE:`)), message);
+};
+
+const logDeployment = (contractName: string, address: string) => {
+  if (verbosity !== 'vv') return;
+  const paddedName = `${contractName} deployed`.padEnd(36);
+  console.log(chalk.green(`  ✓ ${paddedName} ${chalk.bold(address)}`));
+};

package/src/fund.ts

@@ -0,0 +1,62 @@
+import type { WalletClient, PublicClient } from 'viem';
+import { parseEther } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+
+const FUNDER_PRIVATE_KEY = '0xb6b15c8cb491557369f3c7d2c287b053eb229daa9c22138887752191c9520659';
+
+/**
+ * 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.
+ */
+export async function localcofheFundAccount(
+  publicClient: PublicClient,
+  walletClient: WalletClient,
+  toAddress: `0x${string}`,
+  amount: string = '10'
+): Promise<void> {
+  const privateKey = (process.env['FUNDER_PRIVATE_KEY'] ?? FUNDER_PRIVATE_KEY) as `0x${string}`;
+  const funderAccount = privateKeyToAccount(privateKey);
+
+  const balance = await publicClient.getBalance({ address: funderAccount.address });
+  console.log(`Funder wallet address: ${funderAccount.address}`);
+  console.log(`Funder wallet balance: ${balance} wei`);
+
+  const amountWei = parseEther(amount);
+  if (balance < amountWei) {
+    console.error(`Funder wallet doesn't have enough funds. Balance: ${balance} wei, needed: ${amountWei} wei`);
+    return;
+  }
+
+  console.log(`Sending ${amount} ETH to ${toAddress}...`);
+  const hash = await walletClient.sendTransaction({
+    account: funderAccount,
+    to: toAddress,
+    value: amountWei,
+    chain: null,
+  });
+
+  console.log(`Transaction sent! Hash: ${hash}`);
+  const receipt = await publicClient.waitForTransactionReceipt({ hash });
+  console.log(`Transaction confirmed in block ${receipt.blockNumber}`);
+  console.log(`Successfully sent ${amount} ETH to ${toAddress}`);
+}
+
+/**
+ * Checks a wallet's balance and funds it if below 1 ETH.
+ */
+export async function localcofheFundWalletIfNeeded(
+  publicClient: PublicClient,
+  walletClient: WalletClient,
+  walletAddress: `0x${string}`
+): Promise<void> {
+  const balance = await publicClient.getBalance({ address: walletAddress });
+  console.log(`Wallet balance: ${balance} wei`);
+
+  if (balance < parseEther('1')) {
+    console.log(`Balance below 1 ETH. Funding ${walletAddress}...`);
+    await localcofheFundAccount(publicClient, walletClient, walletAddress);
+
+    const newBalance = await publicClient.getBalance({ address: walletAddress });
+    console.log(`New wallet balance: ${newBalance} wei`);
+  }
+}

package/src/hooks/config.ts

@@ -0,0 +1,13 @@
+import type { ConfigHooks } from 'hardhat/types/hooks';
+
+import { resolvePluginConfig } from '../config.js';
+
+const configHooks: Partial<ConfigHooks> = {
+  async resolveUserConfig(userConfig, resolveConfigurationVariable, next) {
+    const resolvedConfig = await next(userConfig, resolveConfigurationVariable);
+    resolvePluginConfig(userConfig, resolvedConfig);
+    return resolvedConfig;
+  },
+};
+
+export default async (): Promise<Partial<ConfigHooks>> => configHooks;

package/src/hooks/hre.ts

@@ -0,0 +1,172 @@
+import type { HardhatRuntimeEnvironmentHooks, NetworkHooks } from 'hardhat/types/hooks';
+import type { HardhatRuntimeEnvironment } from 'hardhat/types/hre';
+import { createPublicClient, createWalletClient, custom, type PublicClient, type WalletClient } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+
+import {
+  MockTaskManagerArtifact,
+  MockACLArtifact,
+  MockZkVerifierArtifact,
+  MockThresholdNetworkArtifact,
+  TestBedArtifact,
+} from '@cofhe/mock-contracts';
+import { MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY, type CofheInputConfig } from '@cofhe/sdk';
+import { createCofheConfig, createCofheClient } from '@cofhe/sdk/node';
+import { hardhat as hardhatChain } from '@cofhe/sdk/chains';
+
+import { deployMocks, type DeployMocksArgs } from '../deploy.js';
+import { mock_setLoggingEnabled, mock_withLogs } from '../logging.js';
+import { mock_getPlaintext, mock_expectPlaintext } from '../utils.js';
+import type { CofheConnection } from '../type-extensions.js';
+
+// ─── Per-connection cofhe object factory ─────────────────────────────────────
+
+function createCofheConnection(
+  publicClient: PublicClient,
+  walletClient: WalletClient,
+  /** Reusable transport factory derived from the walletClient's request method */
+  transport: ReturnType<typeof custom>
+): CofheConnection {
+  return {
+    async createConfig(config: Partial<CofheInputConfig> = {}) {
+      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?: WalletClient) {
+      let signerClient: WalletClient;
+      let address: `0x${string}`;
+
+      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?: DeployMocksArgs) {
+        await deployMocks({ publicClient, walletClient }, options);
+      },
+
+      async withLogs(closureName: string, closure: () => Promise<void>) {
+        await mock_withLogs(publicClient, walletClient, closureName, closure);
+      },
+
+      async enableLogs(closureName?: string) {
+        await mock_setLoggingEnabled(publicClient, walletClient, true, closureName);
+      },
+
+      async disableLogs() {
+        await mock_setLoggingEnabled(publicClient, walletClient, false);
+      },
+
+      async getPlaintext(ctHash: bigint | string) {
+        const value = await mock_getPlaintext(publicClient, ctHash);
+        if (value === undefined) throw new Error('getPlaintext: not on mock network');
+        return value;
+      },
+
+      async expectPlaintext(ctHash: bigint | string, expectedValue: bigint) {
+        await mock_expectPlaintext(publicClient, ctHash, expectedValue);
+      },
+
+      MockTaskManager: {
+        address: MockTaskManagerArtifact.fixedAddress as `0x${string}`,
+        abi: MockTaskManagerArtifact.abi,
+      },
+
+      async MockACL() {
+        const address = await publicClient.readContract({
+          address: MockTaskManagerArtifact.fixedAddress as `0x${string}`,
+          abi: [
+            { name: 'acl', type: 'function', inputs: [], outputs: [{ type: 'address' }], stateMutability: 'view' },
+          ] as const,
+          functionName: 'acl',
+        });
+        return { address, abi: MockACLArtifact.abi };
+      },
+
+      MockZkVerifier: {
+        address: MockZkVerifierArtifact.fixedAddress as `0x${string}`,
+        abi: MockZkVerifierArtifact.abi,
+      },
+
+      MockThresholdNetwork: {
+        address: MockThresholdNetworkArtifact.fixedAddress as `0x${string}`,
+        abi: MockThresholdNetworkArtifact.abi,
+      },
+
+      TestBed: {
+        address: TestBedArtifact.fixedAddress as `0x${string}`,
+        abi: TestBedArtifact.abi,
+      },
+    },
+  };
+}
+
+// ─── HRE hook ─────────────────────────────────────────────────────────────────
+
+const hreHooks: Partial<HardhatRuntimeEnvironmentHooks> = {
+  async created(_context, hre: HardhatRuntimeEnvironment) {
+    // Register a permanent newConnection handler so that every network.connect()
+    // call automatically deploys mocks and attaches conn.cofhe.
+    const networkHandlers: Partial<NetworkHooks> = {
+      async newConnection(context, next) {
+        const conn = await next(context);
+        const transport = custom(conn.provider);
+        const publicClient = createPublicClient({ transport });
+        const walletClient = createWalletClient({ transport });
+        // Derive a reusable transport factory by wrapping the walletClient's
+        // request method — lets us create account-bound clients later.
+        const connTransport = custom({ request: (args: any) => (walletClient as any).request(args) });
+
+        await deployMocks(
+          { publicClient, walletClient },
+          {
+            deployTestBed: true,
+            gasWarning: hre.config.cofhe.gasWarning,
+            mocksDeployVerbosity: hre.config.cofhe.mocksDeployVerbosity,
+          }
+        );
+
+        (conn as any).cofhe = createCofheConnection(publicClient, walletClient, connTransport);
+        return conn;
+      },
+    };
+
+    hre.hooks.registerHandlers('network', networkHandlers);
+  },
+};
+
+export default async (): Promise<Partial<HardhatRuntimeEnvironmentHooks>> => hreHooks;

package/src/index.ts

@@ -0,0 +1,41 @@
+import type { HardhatPlugin } from 'hardhat/types/plugins';
+import { task } from 'hardhat/config';
+import { ArgumentType } from 'hardhat/types/arguments';
+
+import { TASK_COFHE_USE_FAUCET, TASK_COFHE_SET_LOG_OPS } from './consts.js';
+
+import './type-extensions.js';
+
+const plugin: HardhatPlugin = {
+  id: '@cofhe/hardhat-3-plugin',
+
+  hookHandlers: {
+    config: async () => import('./hooks/config.js'),
+    hre: async () => import('./hooks/hre.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: undefined,
+      })
+      .setAction(async () => import('./tasks/use-faucet.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('./tasks/set-log-ops.js'))
+      .build(),
+  ],
+};
+
+export default plugin;
+
+export * from './consts.js';
+export * from './deploy.js';
+export * from './fund.js';
+export * from './logging.js';
+export * from './utils.js';

package/src/logging.ts

@@ -0,0 +1,84 @@
+import type { PublicClient, WalletClient } from 'viem';
+import chalk from 'chalk';
+
+import { MockTaskManagerArtifact } from '@cofhe/mock-contracts';
+import { TASK_MANAGER_ADDRESS } from '@cofhe/sdk';
+
+async function getLoggingEnabled(publicClient: PublicClient): Promise<boolean> {
+  return publicClient.readContract({
+    address: TASK_MANAGER_ADDRESS,
+    abi: MockTaskManagerArtifact.abi,
+    functionName: 'logOps',
+    args: [],
+  }) as Promise<boolean>;
+}
+
+async function setLoggingEnabled(
+  publicClient: PublicClient,
+  walletClient: WalletClient,
+  enabled: boolean
+): Promise<void> {
+  const [account] = await walletClient.getAddresses();
+  const hash = await walletClient.writeContract({
+    address: TASK_MANAGER_ADDRESS,
+    abi: MockTaskManagerArtifact.abi,
+    functionName: 'setLogOps',
+    args: [enabled],
+    account,
+    chain: null,
+  });
+  await publicClient.waitForTransactionReceipt({ hash });
+}
+
+const printLogsEnabledMessage = (closureMessage: string) => {
+  console.log('┌──────────────────┬──────────────────────────────────────────────────');
+  console.log(`│ [COFHE-MOCKS]    │ ${closureMessage}`);
+  console.log('├──────────────────┴──────────────────────────────────────────────────');
+};
+
+const printLogsBlockEnd = () => {
+  console.log('└─────────────────────────────────────────────────────────────────────');
+};
+
+export async function mock_setLoggingEnabled(
+  publicClient: PublicClient,
+  walletClient: WalletClient,
+  enabled: boolean,
+  closureName?: string
+): Promise<void> {
+  try {
+    const initiallyEnabled = await getLoggingEnabled(publicClient);
+    await setLoggingEnabled(publicClient, walletClient, enabled);
+
+    if (enabled) {
+      printLogsEnabledMessage(`${closureName ? `"${chalk.bold(closureName)}" logs:` : 'Logs:'}`);
+    }
+
+    if (!enabled && initiallyEnabled) {
+      printLogsBlockEnd();
+    }
+  } catch (error) {
+    console.log(chalk.red('mock_setLoggingEnabled error'), error);
+  }
+}
+
+export async function mock_withLogs(
+  publicClient: PublicClient,
+  walletClient: WalletClient,
+  closureName: string,
+  closure: () => Promise<void>
+): Promise<void> {
+  const initiallyEnabled = await getLoggingEnabled(publicClient);
+
+  await setLoggingEnabled(publicClient, walletClient, true);
+  printLogsEnabledMessage(`"${chalk.bold(closureName)}" logs:`);
+  try {
+    await closure();
+  } finally {
+    printLogsBlockEnd();
+
+    if (!initiallyEnabled) {
+      await setLoggingEnabled(publicClient, walletClient, false);
+    }
+  }
+}

package/src/tasks/set-log-ops.ts

@@ -0,0 +1,17 @@
+import type { NewTaskActionFunction } from 'hardhat/types/tasks';
+import { createPublicClient, createWalletClient, custom } from 'viem';
+
+import { mock_setLoggingEnabled } from '../logging.js';
+
+interface SetLogOpsTaskArgs {
+  enable: boolean;
+}
+
+const action: NewTaskActionFunction<SetLogOpsTaskArgs> = async ({ enable }, hre) => {
+  const connection = await hre.network.connect();
+  const transport = custom(connection.provider);
+
+  await mock_setLoggingEnabled(createPublicClient({ transport }), createWalletClient({ transport }), enable);
+};
+
+export default action;

package/src/tasks/use-faucet.ts

@@ -0,0 +1,39 @@
+import type { NewTaskActionFunction } from 'hardhat/types/tasks';
+import { createPublicClient, createWalletClient, custom } from 'viem';
+import chalk from 'chalk';
+
+import { localcofheFundAccount } from '../fund.js';
+
+interface UseFaucetTaskArgs {
+  address: string | undefined;
+}
+
+const action: NewTaskActionFunction<UseFaucetTaskArgs> = 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 as `0x${string}`
+    );
+  } catch (e) {
+    console.info(chalk.red(`Failed to get funds from localcofhe for ${address}: ${e}`));
+  }
+};
+
+export default action;