Testing

Common patterns for writing Hardhat tests with the CoFHE plugin

This page shows the common patterns for writing Hardhat tests with the CoFHE plugin.

Test setup

Use hre.cofhe.createClientWithBatteries in a before hook. It creates and connects a fully configured CofheClient — including a self-permit — so the client is ready for every test in the suite:

import hre from 'hardhat';
import { CofheClient } from '@cofhe/sdk';
import { HardhatEthersSigner } from '@nomicfoundation/hardhat-ethers/signers';

let cofheClient: CofheClient;
let signer: HardhatEthersSigner;

before(async () => {
  [signer] = await hre.ethers.getSigners();
  cofheClient = await hre.cofhe.createClientWithBatteries(signer);
});

See Client for manual setup options.

Encrypt → store → decrypt

The core test loop: encrypt a value, pass it to a contract, then decrypt the stored handle.

import { Encryptable, FheTypes } from '@cofhe/sdk';
import { expect } from 'chai';

// 1. Encrypt the input
const encrypted = await cofheClient
  .encryptInputs([Encryptable.uint32(100n)])
  .execute();

// 2. Send to contract
const tx = await testContract.setValue(encrypted[0]);
await tx.wait();

// 3. Read the stored handle
const ctHash = await testContract.storedValue();

// 4. Decrypt for display
const decrypted = await cofheClient
  .decryptForView(ctHash, FheTypes.Uint32)
  .execute();

expect(decrypted).to.equal(100n);

Reading plaintext directly

In tests you can bypass the normal decrypt flow and read the raw plaintext stored by the mock contracts. This is useful for asserting contract state without needing a permit:

import hre from 'hardhat';

// Get raw plaintext value
const plaintext = await hre.cofhe.mocks.getPlaintext(ctHash);

// Or use the assertion shorthand
await hre.cofhe.mocks.expectPlaintext(ctHash, 100n);

See Mock Contracts for details.

Permits

createClientWithBatteries pre-generates a self-permit, so decryptForView and decryptForTx().withPermit() work immediately. For tests that need named permits or multiple signers, create them explicitly:

import { PermitUtils } from '@cofhe/sdk/permits';

const permit = await cofheClient.permits.createSelf({
  issuer: signer.address,
  name: 'My Test Permit',
});

// Select it as the active permit
const permitHash = PermitUtils.getHash(permit);
cofheClient.permits.selectActivePermit(permitHash);

Alternatively, create a separate client for each signer:

import hre from 'hardhat';

const [bob, alice] = await hre.ethers.getSigners();
const bobClient = await hre.cofhe.createClientWithBatteries(bob);
const aliceClient = await hre.cofhe.createClientWithBatteries(alice);

decryptForTx patterns

decryptForTx returns a { ctHash, decryptedValue, signature } tuple for on-chain submission. The permit mode must be selected explicitly.

Globally allowed values (.withoutPermit())

When a contract calls FHE.allowPublic(handle), anyone can decrypt without a permit:

import { expect } from 'chai';

const result = await cofheClient
  .decryptForTx(publicCtHash)
  .withoutPermit()
  .execute();

expect(result.decryptedValue).to.equal(55n);

Access-controlled values (.withPermit())

For handles restricted by ACL policy, supply a permit:

Explicit permit

const result = await cofheClient
  .decryptForTx(ctHash)
  .withPermit(permit)
  .execute();

expect(result.decryptedValue).to.equal(99n);

// resolves the active permit automatically
const result = await cofheClient
  .decryptForTx(ctHash)
  .withPermit()
  .execute();

expect(result.decryptedValue).to.equal(99n);

Submitting the result on-chain

Pass the result directly to your contract:

await myContract.revealValue(
  result.ctHash,
  result.decryptedValue,
  result.signature
);

For a full walkthrough of decryptForTx, see Decrypt to Transact.