@cofhe/hardhat-3-plugin 0.7.1 → 0.8.0

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # @cofhe/hardhat-3-plugin
 
+## 0.8.0
+
+### Minor Changes
+
+- 6f7a4c5: Resolve the Task Manager through the `CoFHEAddressBook` (`@fhenixprotocol/cofhe-contracts@1.0.0`). **Breaking:** `TASK_MANAGER_ADDRESS` is removed from `@cofhe/sdk`. Use `getTaskManagerAddress(publicClient)`, which reads `getTm(TASK_MANAGER_ID)` from the book at `COFHE_ADDRESS_BOOK_ADDRESS` (both exported) and caches the result per chain. If the chain has no book, or the id is unset, it throws `TASK_MANAGER_UNRESOLVED`. `verifyDecryptResult`, the ACL/ACP lookups and `useCofheEnabled` / `useCofheReadDecryptionResults` now resolve the Task Manager this way. `@cofhe/react` adds `useCofheTaskManagerAddress()`.
+
+  Mocks: a new `MockCoFHEAddressBook` is deployed at FHE.sol's `COFHE_ADDRESS_BOOK`, and `MockTaskManager` moves to `MOCKS_TASK_MANAGER_ADDRESS` (`0x…5000`) and is registered in the book. `MockACL` now stores its Task Manager (`setTaskManager` / `getTaskManagerAddress`) instead of reading a constant, so its `TASK_MANAGER_ADDRESS_()` getter is gone. All three plugins deploy and wire the book. Hardhat 2 exposes `hre.cofhe.mocks.getMockCoFHEAddressBook()`, Hardhat 3 exposes `conn.cofhe.mocks.MockCoFHEAddressBook`, and Foundry exposes `CofheTest.mockAddressBook`. Contracts must be built against `@fhenixprotocol/cofhe-contracts@1.0.0` or later (the hardhat plugin's peer range is now `>=1.0.0`). Each FHE op now makes one extra `getTm` call on the book, as it does on real networks, so expect slightly higher gas numbers.
+
+### Patch Changes
+
+- ccb7b68: Realistic gas reporting for mocks. Under Foundry, mock-only work is now excluded from gas metering by default (opt out with `mockTaskManager.setMockGasExcluded(false)`), so expect `forge snapshot` numbers to drop. Under Hardhat, mock transactions emit `MockGasConsumed` events (extra receipt logs), and the plugins add `getAdjustedGasUsed(receipt)` / `getAdjustedGasBreakdown(receipt)` plus an opt-in `cofhe.gasSummary` report.
+- Updated dependencies [17ff23e]
+- Updated dependencies [0fe40c3]
+- Updated dependencies [6f7a4c5]
+- Updated dependencies [552d118]
+- Updated dependencies [22eebcc]
+- Updated dependencies [ccb7b68]
+- Updated dependencies [42fccae]
+  - @cofhe/sdk@0.8.0
+  - @cofhe/mock-contracts@0.8.0
+
 ## 0.7.1
 
 ### Patch Changes

package/README.md

@@ -36,18 +36,20 @@ export default defineConfig({
 
   // 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
+    gasWarning: false, // warn when mock ops report higher gas than real FHE
+    gasSummary: false, // print a per-method adjusted-gas summary after `hardhat test`
+    logMocks: false, // 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                                         |
+| Option       | Type      | Default | Description                                                                                       |
+| ------------ | --------- | ------- | ------------------------------------------------------------------------------------------------- |
+| `gasWarning` | `boolean` | `false` | Print a warning after mock deployment reminding that mock gas costs differ from live FHE          |
+| `gasSummary` | `boolean` | `false` | Print a per-method gas summary after `hardhat test`, with mock-only overhead excluded (see below) |
+| `logMocks`   | `boolean` | `false` | Enable event-based logging inside mock contracts                                                  |
 
 ---
 
@@ -127,6 +129,40 @@ const client = await cofhe.createClientWithBatteries(walletClient);
 
 ---
 
+### `cofhe.getAdjustedGasUsed(receipt)` / `cofhe.getAdjustedGasBreakdown(receipt)`
+
+Mock transactions consume more gas than they would on a real CoFHE network, because the off-chain FHE work is replicated on-chain. The mock task manager measures that overhead and emits a `MockGasConsumed(uint256)` event per block of mock-only work, letting the plugin report corrected numbers:
+
+```typescript
+const hash = await myContract.write.doFheThings();
+const receipt = await publicClient.waitForTransactionReceipt({ hash });
+
+// Gas usage excluding mock overhead — an estimate of real-network cost.
+const adjusted = cofhe.getAdjustedGasUsed(receipt);
+
+// Or the full breakdown:
+const { gasUsed, mockGas, adjustedGasUsed, mockGasEvents } = cofhe.getAdjustedGasBreakdown(receipt);
+```
+
+Both are pure functions of the receipt (no RPC calls). On a real network the receipt carries no mock events, so `adjustedGasUsed` equals `gasUsed` — the same code works everywhere.
+
+With `cofhe: { gasSummary: true }` in the config, a per-method table (raw vs adjusted gas) is printed after `hardhat test`:
+
+```
+[COFHE-MOCKS] Gas summary — adjusted ≈ cost excluding mock-only overhead
+┌──────────────────┬──────────────────────────┬───────┬─────────────────┬────────────────────┬───────────────┐
+│ Contract         │ Method                   │ Calls │ Avg gas (mocks) │ Avg gas (adjusted) │ Mock overhead │
+├──────────────────┼──────────────────────────┼───────┼─────────────────┼────────────────────┼───────────────┤
+│ MyFHEContract    │ doFheThings()            │ 9     │ 146,199         │ 109,595            │ 25%           │
+└──────────────────┴──────────────────────────┴───────┴─────────────────┴────────────────────┴───────────────┘
+```
+
+Note: `eth_estimateGas` is not adjusted — the mock work really does execute, so transactions still need the raw gas limit. Use a testnet for estimate-sensitive flows.
+
+The summary table is collected per test worker at process exit and reconstructed from chain history: transactions rolled back by snapshots won't appear, and it is best-effort after forced exits (`process.exit`, Ctrl+C) — use `getAdjustedGasUsed(receipt)` inside tests for exact per-transaction numbers.
+
+---
+
 ### `cofhe.mocks`
 
 #### Contract descriptors
@@ -205,7 +241,8 @@ The plugin deploys these core contracts automatically on every `network.connect(
 
 | Contract               | Address                                      | Description                                             |
 | ---------------------- | -------------------------------------------- | ------------------------------------------------------- |
-| `MockTaskManager`      | `0xeA30c4B8b44078Bbf8a6ef5b9f1eC1626C7848D9` | Coordinates FHE operations and ACL                      |
+| `MockCoFHEAddressBook` | `0xC0F4e00E531a2B086492Ae3DCC1515038307196b` | Resolves the TaskManager for FHE.sol (`getTm(1)`)       |
+| `MockTaskManager`      | `0x0000000000000000000000000000000000005000` | 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              |

package/dist/chunk-6G2MCXNM.js

@@ -0,0 +1,217 @@
+// src/gas.ts
+import chalk from "chalk";
+import fs from "fs";
+import path from "path";
+import { parseAbiItem, toEventSelector, toFunctionSelector, toFunctionSignature } from "viem";
+import { MOCKS_TASK_MANAGER_ADDRESS } from "@cofhe/sdk";
+var MOCK_GAS_CONSUMED_EVENT = parseAbiItem("event MockGasConsumed(uint256 gas)");
+var MOCK_GAS_CONSUMED_TOPIC = toEventSelector(MOCK_GAS_CONSUMED_EVENT);
+var mock_getAdjustedGasBreakdown = (receipt) => {
+  let mockGas = 0n;
+  let mockGasEvents = 0;
+  for (const log of receipt.logs ?? []) {
+    if (log.address.toLowerCase() === MOCKS_TASK_MANAGER_ADDRESS.toLowerCase() && log.topics[0]?.toLowerCase() === MOCK_GAS_CONSUMED_TOPIC) {
+      mockGas += BigInt(log.data);
+      mockGasEvents += 1;
+    }
+  }
+  const gasUsed = BigInt(receipt.gasUsed);
+  return { gasUsed, mockGas, adjustedGasUsed: mockGas > gasUsed ? 0n : gasUsed - mockGas, mockGasEvents };
+};
+var mock_getAdjustedGasUsed = (receipt) => mock_getAdjustedGasBreakdown(receipt).adjustedGasUsed;
+var SUMMARY_DIR_NAME = "cofhe-gas-summary";
+var registeredConnections = [];
+var summaryDir;
+var exitHookInstalled = false;
+var exitHookRan = false;
+var shortAddress = (address) => `${address.slice(0, 6)}..${address.slice(-4)}`;
+var buildSelectorNameMap = async (artifacts) => {
+  const selectorNames = /* @__PURE__ */ new Map();
+  for (const fqn of await artifacts.getAllFullyQualifiedNames()) {
+    try {
+      const artifact = await artifacts.readArtifact(fqn);
+      for (const item of artifact.abi) {
+        if (item.type !== "function") continue;
+        const selector = toFunctionSelector(item);
+        if (!selectorNames.has(selector)) selectorNames.set(selector, toFunctionSignature(item));
+      }
+    } catch {
+    }
+  }
+  return selectorNames;
+};
+var buildAddressNameMap = async (publicClient, artifacts, addresses) => {
+  const codeToName = /* @__PURE__ */ new Map();
+  for (const fqn of await artifacts.getAllFullyQualifiedNames()) {
+    try {
+      const artifact = await artifacts.readArtifact(fqn);
+      if (artifact.deployedBytecode && artifact.deployedBytecode !== "0x") {
+        codeToName.set(artifact.deployedBytecode.toLowerCase(), artifact.contractName);
+      }
+    } catch {
+    }
+  }
+  const addressNames = /* @__PURE__ */ new Map();
+  for (const address of addresses) {
+    try {
+      const code = await publicClient.getCode({ address }) ?? "0x";
+      addressNames.set(address, codeToName.get(code.toLowerCase()) ?? shortAddress(address));
+    } catch {
+      addressNames.set(address, shortAddress(address));
+    }
+  }
+  return addressNames;
+};
+var collectMockGasRows = async (publicClient, artifacts, fromBlock = 0n) => {
+  let logs;
+  try {
+    logs = await publicClient.getLogs({
+      address: MOCKS_TASK_MANAGER_ADDRESS,
+      event: MOCK_GAS_CONSUMED_EVENT,
+      fromBlock,
+      toBlock: "latest"
+    });
+  } catch {
+    return [];
+  }
+  if (logs.length === 0) return [];
+  const mockGasPerTx = /* @__PURE__ */ new Map();
+  for (const log of logs) {
+    if (log.transactionHash === null) continue;
+    mockGasPerTx.set(log.transactionHash, (mockGasPerTx.get(log.transactionHash) ?? 0n) + (log.args.gas ?? 0n));
+  }
+  const aggregates = /* @__PURE__ */ new Map();
+  for (const [txHash, mockGas] of mockGasPerTx) {
+    try {
+      const receipt = await publicClient.getTransactionReceipt({ hash: txHash });
+      const tx = await publicClient.getTransaction({ hash: txHash });
+      const target = tx.to ?? receipt.contractAddress;
+      if (!target) continue;
+      const selector = tx.to ? (tx.input ?? "0x").slice(0, 10) : "(deployment)";
+      const key = `${target}:${selector}`;
+      const aggregate = aggregates.get(key) ?? { to: target, selector, calls: 0, totalGasUsed: 0n, totalMockGas: 0n };
+      aggregate.calls += 1;
+      aggregate.totalGasUsed += receipt.gasUsed;
+      aggregate.totalMockGas += mockGas;
+      aggregates.set(key, aggregate);
+    } catch {
+    }
+  }
+  if (aggregates.size === 0) return [];
+  const selectorNames = await buildSelectorNameMap(artifacts);
+  const addressNames = await buildAddressNameMap(publicClient, artifacts, [
+    ...new Set([...aggregates.values()].map((a) => a.to))
+  ]);
+  return [...aggregates.values()].map((a) => ({
+    contract: addressNames.get(a.to) ?? shortAddress(a.to),
+    method: selectorNames.get(a.selector) ?? a.selector,
+    calls: a.calls,
+    totalGasUsed: a.totalGasUsed.toString(),
+    totalMockGas: a.totalMockGas.toString()
+  }));
+};
+var registerGasSummaryConnection = (publicClient, artifacts, cacheDir, fromBlock) => {
+  registeredConnections.push({ publicClient, artifacts, fromBlock });
+  summaryDir = path.join(cacheDir, SUMMARY_DIR_NAME);
+  if (exitHookInstalled) return;
+  exitHookInstalled = true;
+  process.on("beforeExit", () => {
+    if (exitHookRan) return;
+    exitHookRan = true;
+    void (async () => {
+      const rows = [];
+      for (const { publicClient: client, artifacts: arts, fromBlock: fromBlock2 } of registeredConnections) {
+        try {
+          rows.push(...await collectMockGasRows(client, arts, fromBlock2));
+        } catch {
+        }
+      }
+      if (rows.length === 0 || summaryDir === void 0) return;
+      try {
+        fs.mkdirSync(summaryDir, { recursive: true });
+        const file = path.join(summaryDir, `rows-${process.pid}-${Date.now()}.json`);
+        fs.writeFileSync(file, JSON.stringify(rows), "utf8");
+      } catch {
+      }
+    })();
+  });
+};
+var cleanGasSummaryDir = (cacheDir) => {
+  try {
+    fs.rmSync(path.join(cacheDir, SUMMARY_DIR_NAME), { recursive: true, force: true });
+  } catch {
+  }
+};
+var printMockGasSummaryFromDir = (cacheDir) => {
+  const dir = path.join(cacheDir, SUMMARY_DIR_NAME);
+  let files;
+  try {
+    files = fs.readdirSync(dir).filter((f) => f.endsWith(".json"));
+  } catch {
+    return;
+  }
+  const merged = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    try {
+      const rows2 = JSON.parse(fs.readFileSync(path.join(dir, file), "utf8"));
+      for (const r of rows2) {
+        const key = `${r.contract}:${r.method}`;
+        const row = merged.get(key) ?? { contract: r.contract, method: r.method, calls: 0, gasUsed: 0n, mockGas: 0n };
+        row.calls += r.calls;
+        row.gasUsed += BigInt(r.totalGasUsed);
+        row.mockGas += BigInt(r.totalMockGas);
+        merged.set(key, row);
+      }
+    } catch {
+    }
+  }
+  cleanGasSummaryDir(cacheDir);
+  if (merged.size === 0) return;
+  const rows = [...merged.values()].map((r) => {
+    const avgGasUsed = r.gasUsed / BigInt(r.calls);
+    const avgMockGas = r.mockGas / BigInt(r.calls);
+    return {
+      contract: r.contract,
+      method: r.method,
+      calls: r.calls,
+      avgGasUsed,
+      avgAdjusted: avgMockGas > avgGasUsed ? 0n : avgGasUsed - avgMockGas,
+      overheadPct: avgGasUsed === 0n ? 0 : Math.min(100, Number(avgMockGas * 100n / avgGasUsed))
+    };
+  }).sort((a, b) => a.contract.localeCompare(b.contract) || a.method.localeCompare(b.method));
+  const headers = ["Contract", "Method", "Calls", "Avg gas (mocks)", "Avg gas (adjusted)", "Mock overhead"];
+  const cells = rows.map((r) => [
+    r.contract,
+    r.method,
+    String(r.calls),
+    r.avgGasUsed.toLocaleString(),
+    r.avgAdjusted.toLocaleString(),
+    `${r.overheadPct}%`
+  ]);
+  const widths = headers.map((h, i) => Math.max(h.length, ...cells.map((row) => row[i].length)));
+  const line = (row) => `\u2502 ${row.map((cell, i) => cell.padEnd(widths[i])).join(" \u2502 ")} \u2502`;
+  const divider = (l, m, r) => `${l}${widths.map((w) => "\u2500".repeat(w + 2)).join(m)}${r}`;
+  console.log("");
+  console.log(chalk.bold("[COFHE-MOCKS] Gas summary") + chalk.dim(" \u2014 adjusted \u2248 cost excluding mock-only overhead"));
+  console.log(divider("\u250C", "\u252C", "\u2510"));
+  console.log(line(headers));
+  console.log(divider("\u251C", "\u253C", "\u2524"));
+  for (const row of cells) console.log(line(row));
+  console.log(divider("\u2514", "\u2534", "\u2518"));
+  console.log(
+    chalk.dim(
+      "Raw numbers include on-chain replication of off-chain CoFHE work; adjusted numbers estimate real-network cost. estimateGas remains unadjusted."
+    )
+  );
+};
+
+export {
+  MOCK_GAS_CONSUMED_EVENT,
+  MOCK_GAS_CONSUMED_TOPIC,
+  mock_getAdjustedGasBreakdown,
+  mock_getAdjustedGasUsed,
+  collectMockGasRows,
+  registerGasSummaryConnection,
+  cleanGasSummaryDir,
+  printMockGasSummaryFromDir
+};

package/dist/{chunk-E7DR6EGV.js → chunk-FDCRLC5K.js}

@@ -2,9 +2,16 @@
 import { createTestClient, custom } from "viem";
 import chalk from "chalk";
 import { privateKeyToAccount } from "viem/accounts";
-import { MockACLArtifact, MockTaskManagerArtifact, MockThresholdNetworkArtifact } from "@cofhe/mock-contracts";
 import {
-  TASK_MANAGER_ADDRESS,
+  MockACLArtifact,
+  MockCoFHEAddressBookArtifact,
+  MockTaskManagerArtifact,
+  MockThresholdNetworkArtifact
+} from "@cofhe/mock-contracts";
+import {
+  COFHE_ADDRESS_BOOK_ADDRESS,
+  TASK_MANAGER_ID,
+  MOCKS_TASK_MANAGER_ADDRESS,
   MOCKS_ZK_VERIFIER_ADDRESS,
   MOCKS_ZK_VERIFIER_SIGNER_ADDRESS,
   MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY,
@@ -28,11 +35,13 @@ async function deployMocks(ctx, options = {}) {
     return {};
   }
   log("vv", chalk.bold("cofhe-hardhat-3-plugin :: deploy mocks"), 0);
-  await deployFixed(ctx.publicClient, "MockTaskManager", TASK_MANAGER_ADDRESS, ctx.artifacts);
-  logDeployment("MockTaskManager", TASK_MANAGER_ADDRESS);
+  await deployFixed(ctx.publicClient, "MockCoFHEAddressBook", COFHE_ADDRESS_BOOK_ADDRESS, ctx.artifacts);
+  logDeployment("MockCoFHEAddressBook", COFHE_ADDRESS_BOOK_ADDRESS);
+  await deployFixed(ctx.publicClient, "MockTaskManager", MOCKS_TASK_MANAGER_ADDRESS, ctx.artifacts);
+  logDeployment("MockTaskManager", MOCKS_TASK_MANAGER_ADDRESS);
   const [account] = await ctx.walletClient.getAddresses();
   await ctx.walletClient.writeContract({
-    address: TASK_MANAGER_ADDRESS,
+    address: MOCKS_TASK_MANAGER_ADDRESS,
     abi: MockTaskManagerArtifact.abi,
     functionName: "initialize",
     args: [account],
@@ -40,7 +49,16 @@ async function deployMocks(ctx, options = {}) {
     chain: null
   });
   await ctx.walletClient.writeContract({
-    address: TASK_MANAGER_ADDRESS,
+    address: COFHE_ADDRESS_BOOK_ADDRESS,
+    abi: MockCoFHEAddressBookArtifact.abi,
+    functionName: "setTm",
+    args: [TASK_MANAGER_ID, MOCKS_TASK_MANAGER_ADDRESS],
+    account,
+    chain: null
+  });
+  log("vv", "TaskManager registered in CoFHEAddressBook", 2);
+  await ctx.walletClient.writeContract({
+    address: MOCKS_TASK_MANAGER_ADDRESS,
     abi: MockTaskManagerArtifact.abi,
     functionName: "setSecurityZones",
     args: [0, 1],
@@ -50,7 +68,7 @@ async function deployMocks(ctx, options = {}) {
   const aclAddress = await deployVariable(ctx, "MockACL", []);
   logDeployment("MockACL", aclAddress);
   await ctx.walletClient.writeContract({
-    address: TASK_MANAGER_ADDRESS,
+    address: MOCKS_TASK_MANAGER_ADDRESS,
     abi: MockTaskManagerArtifact.abi,
     functionName: "setACLContract",
     args: [aclAddress],
@@ -58,6 +76,15 @@ async function deployMocks(ctx, options = {}) {
     chain: null
   });
   log("vv", "ACL address set in TaskManager", 2);
+  await ctx.walletClient.writeContract({
+    address: aclAddress,
+    abi: MockACLArtifact.abi,
+    functionName: "setTaskManager",
+    args: [MOCKS_TASK_MANAGER_ADDRESS],
+    account,
+    chain: null
+  });
+  log("vv", "TaskManager address set in ACL", 2);
   const acpRevokerAddress = await deployVariable(ctx, "ACPTimestampRevoker", []);
   logDeployment("ACPTimestampRevoker", acpRevokerAddress);
   await ctx.walletClient.writeContract({
@@ -82,7 +109,7 @@ async function deployMocks(ctx, options = {}) {
   log("vv", "Share registry set in ACL", 2);
   const verifierSigner = privateKeyToAccount(MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY);
   await ctx.walletClient.writeContract({
-    address: TASK_MANAGER_ADDRESS,
+    address: MOCKS_TASK_MANAGER_ADDRESS,
     abi: MockTaskManagerArtifact.abi,
     functionName: "setVerifierSigner",
     args: [verifierSigner.address],
@@ -92,7 +119,7 @@ async function deployMocks(ctx, options = {}) {
   log("vv", "Verifier signer set", 2);
   const decryptSigner = privateKeyToAccount(MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY);
   await ctx.walletClient.writeContract({
-    address: TASK_MANAGER_ADDRESS,
+    address: MOCKS_TASK_MANAGER_ADDRESS,
     abi: MockTaskManagerArtifact.abi,
     functionName: "setDecryptResultSigner",
     args: [decryptSigner.address],
@@ -120,7 +147,7 @@ async function deployMocks(ctx, options = {}) {
     address: MockThresholdNetworkArtifact.fixedAddress,
     abi: MockThresholdNetworkArtifact.abi,
     functionName: "initialize",
-    args: [TASK_MANAGER_ADDRESS, aclAddress],
+    args: [MOCKS_TASK_MANAGER_ADDRESS, aclAddress],
     account,
     chain: null
   });
@@ -128,13 +155,14 @@ async function deployMocks(ctx, options = {}) {
   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)",
+      "When using mocks, FHE operations consume extra gas replicating off-chain CoFHE work on-chain. Use conn.cofhe.getAdjustedGasUsed(receipt) or set 'cofhe.gasSummary: true' to see gas numbers with that overhead excluded.\n(Disable this warning by setting 'cofhe.gasWarning: false' in your Hardhat config)",
       0
     );
   }
   logEmpty("v");
   return {
-    MockTaskManager: TASK_MANAGER_ADDRESS,
+    MockCoFHEAddressBook: COFHE_ADDRESS_BOOK_ADDRESS,
+    MockTaskManager: MOCKS_TASK_MANAGER_ADDRESS,
     MockACL: aclAddress,
     ACPTimestampRevoker: acpRevokerAddress,
     ACPShareRegistry: acpShareRegistryAddress,
@@ -186,7 +214,7 @@ var logDeployment = (contractName, address) => {
 };
 
 // src/utils.ts
-import { TASK_MANAGER_ADDRESS as TASK_MANAGER_ADDRESS2, MOCKS_ZK_VERIFIER_ADDRESS as MOCKS_ZK_VERIFIER_ADDRESS2 } from "@cofhe/sdk";
+import { MOCKS_TASK_MANAGER_ADDRESS as MOCKS_TASK_MANAGER_ADDRESS2, MOCKS_ZK_VERIFIER_ADDRESS as MOCKS_ZK_VERIFIER_ADDRESS2 } from "@cofhe/sdk";
 import path from "path";
 import fs from "fs";
 import { createRequire } from "module";
@@ -216,7 +244,7 @@ async function mock_getPlaintext(publicClient, ctHash) {
     return void 0;
   }
   return publicClient.readContract({
-    address: TASK_MANAGER_ADDRESS2,
+    address: MOCKS_TASK_MANAGER_ADDRESS2,
     abi: [
       {
         name: "mockStorage",
@@ -236,7 +264,7 @@ async function mock_expectPlaintext(publicClient, ctHash, expectedValue) {
     return;
   }
   const exists = await publicClient.readContract({
-    address: TASK_MANAGER_ADDRESS2,
+    address: MOCKS_TASK_MANAGER_ADDRESS2,
     abi: [
       {
         name: "inMockStorage",

package/dist/{chunk-IVRNGFNF.js → chunk-NYXXHYHW.js}

@@ -1,10 +1,10 @@
 // src/logging.ts
 import chalk from "chalk";
 import { MockTaskManagerArtifact } from "@cofhe/mock-contracts";
-import { TASK_MANAGER_ADDRESS } from "@cofhe/sdk";
+import { MOCKS_TASK_MANAGER_ADDRESS } from "@cofhe/sdk";
 async function getLoggingEnabled(publicClient) {
   return publicClient.readContract({
-    address: TASK_MANAGER_ADDRESS,
+    address: MOCKS_TASK_MANAGER_ADDRESS,
     abi: MockTaskManagerArtifact.abi,
     functionName: "logOps",
     args: []
@@ -13,7 +13,7 @@ async function getLoggingEnabled(publicClient) {
 async function setLoggingEnabled(publicClient, walletClient, enabled) {
   const [account] = await walletClient.getAddresses();
   const hash = await walletClient.writeContract({
-    address: TASK_MANAGER_ADDRESS,
+    address: MOCKS_TASK_MANAGER_ADDRESS,
     abi: MockTaskManagerArtifact.abi,
     functionName: "setLogOps",
     args: [enabled],

package/dist/{config-YK3LB5IH.js → config-VUCAYBHC.js}

@@ -46,6 +46,7 @@ function resolvePluginConfig(userConfig, resolvedConfig) {
   resolvedConfig.cofhe = {
     logMocks: userConfig.cofhe?.logMocks ?? false,
     gasWarning: userConfig.cofhe?.gasWarning ?? false,
+    gasSummary: userConfig.cofhe?.gasSummary ?? false,
     mocksDeployVerbosity: userConfig.cofhe?.mocksDeployVerbosity ?? "v"
   };
 }

package/dist/{hre-CYH6NXPG.js → hre-T3TPXWIY.js}

@@ -3,17 +3,23 @@ import {
   getMockContractsNpmPaths,
   mock_expectPlaintext,
   mock_getPlaintext
-} from "./chunk-E7DR6EGV.js";
+} from "./chunk-FDCRLC5K.js";
 import {
   mock_setLoggingEnabled,
   mock_withLogs
-} from "./chunk-IVRNGFNF.js";
+} from "./chunk-NYXXHYHW.js";
+import {
+  mock_getAdjustedGasBreakdown,
+  mock_getAdjustedGasUsed,
+  registerGasSummaryConnection
+} from "./chunk-6G2MCXNM.js";
 
 // src/hooks/hre.ts
 import { FileBuildResultType } from "hardhat/types/solidity";
 import { createPublicClient, createWalletClient, custom } from "viem";
 import { privateKeyToAccount } from "viem/accounts";
 import {
+  MockCoFHEAddressBookArtifact,
   MockTaskManagerArtifact,
   MockACLArtifact,
   MockZkVerifierArtifact,
@@ -44,6 +50,8 @@ function createCofheConnection(publicClient, walletClient, transport, artifacts,
     createClient(config) {
       return createCofheClient(config);
     },
+    getAdjustedGasUsed: mock_getAdjustedGasUsed,
+    getAdjustedGasBreakdown: mock_getAdjustedGasBreakdown,
     async createClientWithBatteries(signerWalletClient) {
       let signerClient;
       let address;
@@ -85,6 +93,10 @@ function createCofheConnection(publicClient, walletClient, transport, artifacts,
       async expectPlaintext(ctHash, expectedValue) {
         await mock_expectPlaintext(publicClient, ctHash, expectedValue);
       },
+      MockCoFHEAddressBook: {
+        address: deployedMockContracts.MockCoFHEAddressBook,
+        abi: MockCoFHEAddressBookArtifact.abi
+      },
       MockTaskManager: { address: deployedMockContracts.MockTaskManager, abi: MockTaskManagerArtifact.abi },
       MockACL: { address: deployedMockContracts.MockACL, abi: MockACLArtifact.abi },
       MockZkVerifier: { address: deployedMockContracts.MockZkVerifier, abi: MockZkVerifierArtifact.abi },
@@ -136,6 +148,10 @@ var hreHooks = {
             mocksDeployVerbosity: hre.config.cofhe.mocksDeployVerbosity
           }
         );
+        if (hre.config.cofhe.gasSummary && deployedMockContracts.MockTaskManager !== void 0) {
+          const fromBlock = await publicClient.getBlockNumber();
+          registerGasSummaryConnection(publicClient, hre.artifacts, hre.config.paths.cache, fromBlock);
+        }
         conn.cofhe = createCofheConnection(
           publicClient,
           walletClient,