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

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# @cofhe/hardhat-3-plugin
+
+## 0.0.0-alpha-20260409113701
+
+### 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

package/README.md

@@ -0,0 +1,270 @@
+# @cofhe/hardhat-3-plugin
+
+A [Hardhat 3](https://hardhat.org) plugin for [CoFHE](https://docs.fhenix.io) development. It deploys the CoFHE mock contracts to an in-process Hardhat network on every `network.connect()` call and exposes a `cofhe` namespace on the connection object — ready to use immediately, no boilerplate required.
+
+## Features
+
+- Automatically deploys all CoFHE mock contracts (`MockTaskManager`, `MockACL`, `MockZkVerifier`, `MockThresholdNetwork`, `TestBed`) on every `network.connect()`
+- Exposes `conn.cofhe` on the Hardhat 3 connection object (compatible with `@nomicfoundation/hardhat-viem`'s `conn.viem`)
+- Provides a batteries-included `cofhe.createClientWithBatteries()` for quick SDK client setup
+- Mock-specific helpers: plaintext inspection, logging control, and Viem contract descriptors for every mock
+
+---
+
+## Installation
+
+```bash
+npm install @cofhe/hardhat-3-plugin
+# or
+pnpm add @cofhe/hardhat-3-plugin
+```
+
+---
+
+## Configuration
+
+Register the plugin in `hardhat.config.ts`:
+
+```typescript
+import { defineConfig } from 'hardhat/config';
+import cofhePlugin from '@cofhe/hardhat-3-plugin';
+import hardhatViem from '@nomicfoundation/hardhat-viem';
+import hardhatNodeTestRunner from '@nomicfoundation/hardhat-node-test-runner';
+
+export default defineConfig({
+  plugins: [cofhePlugin, hardhatViem, hardhatNodeTestRunner],
+
+  // Optional cofhe config (all values shown are their defaults)
+  cofhe: {
+    gasWarning: true, // warn when mock ops report higher gas than real FHE
+    logMocks: true, // enable mock contract event logging
+  },
+});
+```
+
+### Config options
+
+| Option       | Type      | Default | Description                                                                              |
+| ------------ | --------- | ------- | ---------------------------------------------------------------------------------------- |
+| `gasWarning` | `boolean` | `true`  | Print a warning after mock deployment reminding that mock gas costs differ from live FHE |
+| `logMocks`   | `boolean` | `true`  | Enable event-based logging inside mock contracts                                         |
+
+---
+
+## Usage
+
+### The `cofhe` connection object
+
+Every call to `network.connect()` automatically:
+
+1. Deploys all CoFHE mock contracts to the fresh in-process EVM
+2. Attaches a `cofhe` namespace to the returned connection object
+
+Because `network.connect()` is awaitable at the top level of an `async describe`, you can set everything up without lifecycle hooks:
+
+```typescript
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { network } from 'hardhat';
+
+describe('My FHE contract', async () => {
+  const { viem, cofhe } = await network.connect();
+  const publicClient = await viem.getPublicClient();
+  const [walletClient] = await viem.getWalletClients();
+
+  it('encrypts and decrypts a value', async () => {
+    const client = await cofhe.createClientWithBatteries(walletClient);
+    // ... test logic
+  });
+});
+```
+
+> **Why `async describe`?**  
+> Hardhat 3's node:test runner supports top-level `await` inside the describe callback. This lets you resolve the connection (and deploy mocks) exactly once per test file without needing a `before()` hook.
+
+---
+
+## API reference
+
+### `cofhe.createConfig(overrides?)`
+
+Creates a CoFHE SDK configuration pre-wired for the Hardhat mock environment.
+
+```typescript
+const config = await cofhe.createConfig();
+// With overrides:
+const config = await cofhe.createConfig({ mocks: { encryptDelay: 0 } });
+```
+
+Returns a `CofheConfig` object suitable for `cofhe.createClient()`.
+
+---
+
+### `cofhe.createClient(config)`
+
+Creates a `CofheClient` from a config. The client is **not connected** — call `client.connect(publicClient, walletClient)` before using it.
+
+```typescript
+const config = await cofhe.createConfig();
+const client = cofhe.createClient(config);
+await client.connect(publicClient, walletClient);
+```
+
+---
+
+### `cofhe.createClientWithBatteries(walletClient?)`
+
+Creates a fully initialized `CofheClient` in one call — configures it for Hardhat, connects it, and creates a self-permit so it can decrypt encrypted FHE variables out of the box.
+
+```typescript
+// Uses the first account in the connection automatically:
+const client = await cofhe.createClientWithBatteries();
+
+// Or pass a specific account-bound wallet client:
+const [walletClient] = await viem.getWalletClients();
+const client = await cofhe.createClientWithBatteries(walletClient);
+```
+
+---
+
+### `cofhe.mocks`
+
+#### Contract descriptors
+
+Each mock contract is exposed as an `{ address, abi }` object that can be spread directly into Viem's `readContract` / `writeContract`:
+
+```typescript
+// Fixed-address contracts (synchronous):
+cofhe.mocks.MockTaskManager; // { address: `0x...`, abi: [...] }
+cofhe.mocks.MockZkVerifier; // { address: `0x...`, abi: [...] }
+cofhe.mocks.MockThresholdNetwork; // { address: `0x...`, abi: [...] }
+cofhe.mocks.TestBed; // { address: `0x...`, abi: [...] }
+
+// Dynamic-address contract (async — resolves from TaskManager on-chain):
+const mockACL = await cofhe.mocks.MockACL(); // { address: `0x...`, abi: [...] }
+```
+
+Example — calling a mock directly with Viem:
+
+```typescript
+const value = await publicClient.readContract({
+  ...cofhe.mocks.TestBed,
+  functionName: 'numberHash',
+});
+
+await walletClient.writeContract({
+  ...cofhe.mocks.MockTaskManager,
+  functionName: 'setSecurityZones',
+  args: [0, 1],
+});
+```
+
+#### Plaintext inspection
+
+In the mock environment, every FHE ciphertext has a corresponding plaintext stored on-chain. These helpers let you inspect or assert on plaintext values without decryption:
+
+```typescript
+// Returns the plaintext bigint for a ciphertext hash
+const plaintext = await cofhe.mocks.getPlaintext(ctHash);
+
+// Throws if the plaintext doesn't match the expected value
+await cofhe.mocks.expectPlaintext(ctHash, 42n);
+```
+
+Both methods accept a `ctHash` as either a `bigint` or a hex `string`.
+
+#### Logging control
+
+Mock contracts can emit structured logs for every FHE operation, which is useful for debugging. Logging is disabled by default.
+
+```typescript
+// Enable logging
+await cofhe.mocks.enableLogs();
+
+// Disable logging
+await cofhe.mocks.disableLogs();
+
+// Enable only for a specific block of code, then restore previous state
+await cofhe.mocks.withLogs('my test', async () => {
+  // ... FHE operations are logged here
+});
+```
+
+#### `cofhe.mocks.deployMocks(options?)`
+
+Re-deploys all mock contracts. Normally you don't need to call this directly — mocks are deployed automatically on every `network.connect()`. This is available for advanced scenarios where you need to reset mock state mid-test.
+
+```typescript
+await cofhe.mocks.deployMocks({ deployTestBed: true, silent: true });
+```
+
+| Option          | Type      | Default         | Description                                      |
+| --------------- | --------- | --------------- | ------------------------------------------------ |
+| `deployTestBed` | `boolean` | `true`          | Whether to deploy the `TestBed` utility contract |
+| `gasWarning`    | `boolean` | inherits config | Print gas warning after deployment               |
+| `silent`        | `boolean` | `false`         | Suppress all deployment output                   |
+
+---
+
+## Mock contracts
+
+The plugin deploys these contracts automatically on every `network.connect()`:
+
+| Contract               | Address                                      | Description                                                           |
+| ---------------------- | -------------------------------------------- | --------------------------------------------------------------------- |
+| `MockTaskManager`      | `0xeA30c4B8b44078Bbf8a6ef5b9f1eC1626C7848D9` | Coordinates FHE operations and ACL                                    |
+| `MockACL`              | dynamic                                      | Access Control List — address resolved from TaskManager               |
+| `MockZkVerifier`       | `0x0000000000000000000000000000000000005001` | Verifies ZK proofs for encrypted inputs                               |
+| `MockThresholdNetwork` | `0x0000000000000000000000000000000000005002` | Simulates the threshold decryption network                            |
+| `TestBed`              | `0x0000000000000000000000000000000000005003` | Utility contract for storing and retrieving encrypted values in tests |
+
+Fixed-address contracts are deployed via `hardhat_setCode`, ensuring they are always at the same address regardless of deployment order. `MockACL` is deployed as a normal contract (so its EIP-712 domain constructor runs correctly) and its address is registered in `MockTaskManager`.
+
+---
+
+## Complete test example
+
+```typescript
+import { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { network } from 'hardhat';
+import { Encryptable, FheTypes } from '@cofhe/sdk';
+
+describe('Encrypted counter', async () => {
+  const { viem, cofhe } = await network.connect();
+  const publicClient = await viem.getPublicClient();
+  const [walletClient] = await viem.getWalletClients();
+
+  it('encrypts, stores, and decrypts a uint32', async () => {
+    const client = await cofhe.createClientWithBatteries(walletClient);
+
+    // Encrypt
+    const [enc] = await client.encryptInputs([Encryptable.uint32(42n)]).execute();
+
+    // Store on-chain via TestBed
+    await walletClient.writeContract({
+      ...cofhe.mocks.TestBed,
+      functionName: 'setNumber',
+      args: [{ ctHash: enc.ctHash, securityZone: enc.securityZone, utype: enc.utype, signature: enc.signature }],
+    });
+
+    const ctHash = (await publicClient.readContract({
+      ...cofhe.mocks.TestBed,
+      functionName: 'numberHash',
+    })) as `0x${string}`;
+
+    // Decrypt via view (off-chain, instant)
+    const decryptedView = await client.decryptForView(ctHash, FheTypes.Uint32).execute();
+    assert.equal(decryptedView, 42n);
+
+    // Alternatively, verify plaintext without decryption
+    await cofhe.mocks.expectPlaintext(ctHash, 42n);
+  });
+});
+```
+
+---
+
+## License
+
+MIT

package/dist/chunk-5FCSZD6A.js

@@ -0,0 +1,223 @@
+// src/deploy.ts
+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";
+var verbosity = "v";
+async function isLocalHardhatNetwork(publicClient) {
+  try {
+    await publicClient.request({ method: "hardhat_metadata", params: [] });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function deployMocks(ctx, options = {}) {
+  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);
+  await deployFixed(ctx.publicClient, MockTaskManagerArtifact);
+  logDeployment("MockTaskManager", TASK_MANAGER_ADDRESS);
+  const [account] = await ctx.walletClient.getAddresses();
+  await ctx.walletClient.writeContract({
+    address: TASK_MANAGER_ADDRESS,
+    abi: MockTaskManagerArtifact.abi,
+    functionName: "initialize",
+    args: [account],
+    account,
+    chain: null
+  });
+  await ctx.walletClient.writeContract({
+    address: TASK_MANAGER_ADDRESS,
+    abi: MockTaskManagerArtifact.abi,
+    functionName: "setSecurityZones",
+    args: [0, 1],
+    account,
+    chain: null
+  });
+  const aclAddress = await deployVariable(ctx, MockACLArtifact, []);
+  logDeployment("MockACL", aclAddress);
+  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);
+  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);
+  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);
+  const testClient = createTestClient({
+    mode: "hardhat",
+    transport: custom(ctx.publicClient.transport)
+  });
+  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);
+  await deployFixed(ctx.publicClient, MockZkVerifierArtifact);
+  logDeployment("MockZkVerifier", MOCKS_ZK_VERIFIER_ADDRESS);
+  await deployFixed(ctx.publicClient, MockThresholdNetworkArtifact);
+  logDeployment("MockThresholdNetwork", MockThresholdNetworkArtifact.fixedAddress);
+  await ctx.walletClient.writeContract({
+    address: MockThresholdNetworkArtifact.fixedAddress,
+    abi: MockThresholdNetworkArtifact.abi,
+    functionName: "initialize",
+    args: [TASK_MANAGER_ADDRESS, aclAddress],
+    account,
+    chain: null
+  });
+  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");
+}
+async function deployFixed(publicClient, artifact) {
+  await publicClient.request({
+    method: "hardhat_setCode",
+    params: [artifact.fixedAddress, artifact.deployedBytecode]
+  });
+}
+async function deployVariable(ctx, artifact, constructorArgs) {
+  const [account] = await ctx.walletClient.getAddresses();
+  const hash = await ctx.walletClient.deployContract({
+    abi: artifact.abi,
+    bytecode: artifact.bytecode,
+    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;
+}
+var log = (minVerbosity, message, indent = 1) => {
+  if (verbosity === "") return;
+  if (minVerbosity === "vv" && verbosity !== "vv") return;
+  console.log(chalk.green(`${"  ".repeat(indent)}\u2713 ${message}`));
+};
+var logEmpty = (minVerbosity = "v") => {
+  if (verbosity === "") return;
+  if (minVerbosity === "vv" && verbosity !== "vv") return;
+  console.log("");
+};
+var logWarning = (message, indent = 1) => {
+  if (verbosity === "") return;
+  console.log(chalk.bold(chalk.yellow(`${"  ".repeat(indent)}\u26A0 NOTE:`)), message);
+};
+var logDeployment = (contractName, address) => {
+  if (verbosity !== "vv") return;
+  const paddedName = `${contractName} deployed`.padEnd(36);
+  console.log(chalk.green(`  \u2713 ${paddedName} ${chalk.bold(address)}`));
+};
+
+// src/utils.ts
+import { TASK_MANAGER_ADDRESS as TASK_MANAGER_ADDRESS2, MOCKS_ZK_VERIFIER_ADDRESS as MOCKS_ZK_VERIFIER_ADDRESS2 } from "@cofhe/sdk";
+async function isMockEnvironment(publicClient) {
+  const bytecode = await publicClient.getCode({
+    address: MOCKS_ZK_VERIFIER_ADDRESS2
+  });
+  return !!bytecode && bytecode.length > 2;
+}
+async function mock_getPlaintext(publicClient, ctHash) {
+  if (!await isMockEnvironment(publicClient)) {
+    console.log("mock_getPlaintext \u2014 skipped on non-mock network");
+    return void 0;
+  }
+  return publicClient.readContract({
+    address: TASK_MANAGER_ADDRESS2,
+    abi: [
+      {
+        name: "mockStorage",
+        type: "function",
+        inputs: [{ name: "ctHash", type: "uint256" }],
+        outputs: [{ type: "uint256" }],
+        stateMutability: "view"
+      }
+    ],
+    functionName: "mockStorage",
+    args: [BigInt(ctHash)]
+  });
+}
+async function mock_expectPlaintext(publicClient, ctHash, expectedValue) {
+  if (!await isMockEnvironment(publicClient)) {
+    console.log("mock_expectPlaintext \u2014 skipped on non-mock network");
+    return;
+  }
+  const exists = await publicClient.readContract({
+    address: TASK_MANAGER_ADDRESS2,
+    abi: [
+      {
+        name: "inMockStorage",
+        type: "function",
+        inputs: [{ name: "ctHash", type: "uint256" }],
+        outputs: [{ type: "bool" }],
+        stateMutability: "view"
+      }
+    ],
+    functionName: "inMockStorage",
+    args: [BigInt(ctHash)]
+  });
+  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}`);
+  }
+}
+
+export {
+  deployMocks,
+  mock_getPlaintext,
+  mock_expectPlaintext
+};

package/dist/chunk-IVRNGFNF.js

@@ -0,0 +1,64 @@
+// src/logging.ts
+import chalk from "chalk";
+import { MockTaskManagerArtifact } from "@cofhe/mock-contracts";
+import { TASK_MANAGER_ADDRESS } from "@cofhe/sdk";
+async function getLoggingEnabled(publicClient) {
+  return publicClient.readContract({
+    address: TASK_MANAGER_ADDRESS,
+    abi: MockTaskManagerArtifact.abi,
+    functionName: "logOps",
+    args: []
+  });
+}
+async function setLoggingEnabled(publicClient, walletClient, enabled) {
+  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 });
+}
+var printLogsEnabledMessage = (closureMessage) => {
+  console.log("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  console.log(`\u2502 [COFHE-MOCKS]    \u2502 ${closureMessage}`);
+  console.log("\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+};
+var printLogsBlockEnd = () => {
+  console.log("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+};
+async function mock_setLoggingEnabled(publicClient, walletClient, enabled, closureName) {
+  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);
+  }
+}
+async function mock_withLogs(publicClient, walletClient, closureName, closure) {
+  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);
+    }
+  }
+}
+
+export {
+  mock_setLoggingEnabled,
+  mock_withLogs
+};

package/dist/chunk-Z2FAJP4Y.js

@@ -0,0 +1,42 @@
+// src/fund.ts
+import { parseEther } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+var FUNDER_PRIVATE_KEY = "0xb6b15c8cb491557369f3c7d2c287b053eb229daa9c22138887752191c9520659";
+async function localcofheFundAccount(publicClient, walletClient, toAddress, amount = "10") {
+  const privateKey = process.env["FUNDER_PRIVATE_KEY"] ?? FUNDER_PRIVATE_KEY;
+  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}`);
+}
+async function localcofheFundWalletIfNeeded(publicClient, walletClient, walletAddress) {
+  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`);
+  }
+}
+
+export {
+  localcofheFundAccount,
+  localcofheFundWalletIfNeeded
+};

package/dist/config-YK3LB5IH.js

@@ -0,0 +1,64 @@
+// src/config.ts
+function resolvePluginConfig(userConfig, resolvedConfig) {
+  if (!userConfig.networks?.["localcofhe"]) {
+    resolvedConfig.networks["localcofhe"] = {
+      type: "http",
+      url: "http://127.0.0.1:42069",
+      gas: "auto",
+      gasMultiplier: 1.2,
+      gasPrice: "auto",
+      timeout: 1e4,
+      httpHeaders: {},
+      accounts: [
+        "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80",
+        "0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d",
+        "0x5de4111afa1a4b94908f83103eb1f1706367c2e68ca870fc3fb9a804cdab365a",
+        "0x7c852118294e51e653712a81e05800f419141751be58f605c371e15141b007a6"
+      ]
+    };
+  }
+  if (!userConfig.networks?.["eth-sepolia"]) {
+    resolvedConfig.networks["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: 6e4,
+      httpHeaders: {}
+    };
+  }
+  if (!userConfig.networks?.["arb-sepolia"]) {
+    resolvedConfig.networks["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: 6e4,
+      httpHeaders: {}
+    };
+  }
+  resolvedConfig.cofhe = {
+    logMocks: userConfig.cofhe?.logMocks ?? false,
+    gasWarning: userConfig.cofhe?.gasWarning ?? false,
+    mocksDeployVerbosity: userConfig.cofhe?.mocksDeployVerbosity ?? "v"
+  };
+}
+
+// src/hooks/config.ts
+var configHooks = {
+  async resolveUserConfig(userConfig, resolveConfigurationVariable, next) {
+    const resolvedConfig = await next(userConfig, resolveConfigurationVariable);
+    resolvePluginConfig(userConfig, resolvedConfig);
+    return resolvedConfig;
+  }
+};
+var config_default = async () => configHooks;
+export {
+  config_default as default
+};