Testing

This page builds one test file for an encrypted counter. It then covers the patterns you add as a contract grows: plaintext assertions, ACPs (Access Control Permissions), and decryption for a transaction. It assumes the setup from Getting Started.

The contract

The examples use this contract. It accepts an encrypted input, increments the stored value, and can publish a decryption result onchain.

contracts/Counter.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.28;

import '@fhenixprotocol/cofhe-contracts/FHE.sol';

contract Counter {
  euint32 public count;

  function setCount(externalEuint32 inValue, bytes calldata inputProof) external {
    count = FHE.asEuint32(inValue, inputProof);
    FHE.allowThis(count);
    FHE.allowSender(count);
  }

  function increment() external {
    count = FHE.add(count, FHE.asEuint32(1));
    FHE.allowThis(count);
    FHE.allowSender(count);
  }

  function revealCount() external {
    FHE.allowPublic(count);
  }

  function publishCount(uint32 plaintext, bytes calldata signature) external {
    FHE.publishDecryptResult(count, plaintext, signature);
  }
}

Encrypt, store, and decrypt

The core test loop encrypts a value, sends it to the contract, and decrypts the stored handle:

test/Counter.test.ts

import { describe, it } from 'node:test';
import assert from 'node:assert/strict';
import { network } from 'hardhat';
import { Encryptable, FheTypes } from '@cofhe/sdk';

describe('Counter', async () => {
  const { viem, cofhe } = await network.create();
  const [walletClient] = await viem.getWalletClients();

  it('stores and decrypts an encrypted count', async () => {
    const counter = await viem.deployContract('Counter');
    const client = await cofhe.createClientWithBatteries(walletClient);

    // The signature is bound to the contract that consumes the input
    const [countHash, signature] = await client
      .encryptInputs([Encryptable.uint32(42n)])
      .setConsumingContract(counter.address)
      .execute();

    await counter.write.setCount([countHash, signature]);

    const ctHash = await counter.read.count();
    const count = await client.decryptForView(ctHash, FheTypes.Uint32).execute();

    assert.equal(count, 42n);
  });
});

Run it:

npx hardhat test

The output lists the stores and decrypts an encrypted count test under Counter, and the summary reads 1 passing (1 nodejs).

The describe callback is async so that it can await network.create() at the top. Every it inside it shares that connection and its mocks, without a before hook.

Start each test from a clean chain

A connection is one chain, so tests in the same describe see each other’s state. When a test needs a clean chain, open a new connection inside it:

it('starts from a clean chain', async () => {
  const { viem, cofhe } = await network.create();
  const counter = await viem.deployContract('Counter');
  // ...
});

Each network.create() call starts a new simulated chain and deploys a new set of mocks. Contracts from other connections do not exist on it.

Assert on plaintext

Reading the plaintext from the mocks is faster than a decryption and needs no ACP:

await counter.write.increment();

await cofhe.mocks.expectPlaintext(await counter.read.count(), 43n);

Use decryptForView when the SDK’s own behavior is under test. See Mock contracts for both plaintext helpers.

Named ACPs

createClientWithBatteries creates and selects a self ACP. For a test that needs a second ACP, create it and select it:

import { ACPUtils } from '@cofhe/sdk/acps';

const acp = await client.acp.createSelf({
  issuer: walletClient.account.address,
  name: 'Counter test ACP',
});

client.acp.selectActiveACP(ACPUtils.getHash(acp));

For several signers, create one client per wallet, as shown on the Client page.

Decrypt for a transaction

decryptForTx resolves to { ctHash, decryptedValue, signature }. Choose the ACP mode before execute().

Public handles

After the contract calls FHE.allowPublic, anyone can decrypt the handle without an ACP:

await counter.write.increment();
await counter.write.revealCount();

const result = await client
  .decryptForTx(await counter.read.count())
  .withoutACP()
  .execute();

assert.equal(result.decryptedValue, 1n);

On a handle that is not public, withoutACP() rejects with mocks decryptForTx call failed: NotAllowed.

Handles restricted by the ACL

Pass an ACP, or call withACP() with no argument to use the active one:

const result = await client
  .decryptForTx(ctHash)
  .withACP()
  .execute();

const result = await client
  .decryptForTx(ctHash)
  .withACP(acp)
  .execute();

Publish the result onchain

Send the value and the signature to the contract, which verifies and stores them with FHE.publishDecryptResult:

await counter.write.publishCount([Number(result.decryptedValue), result.signature]);

decryptedValue is a bigint. viem expects a number for a uint32 argument, so convert it first.

Common pitfalls

Every test fails with HHE1000

HHE1000: Artifact for contract "MockTaskManager" not found means the mock contracts are missing from solidity.npmFilesToBuild. Add them as shown in Getting Started.

TypeScript rejects the wallet client

Error TS2345 on createClientWithBatteries(walletClient) or client.connect(...) means two copies of viem are installed. Add the viem override from Getting Started and reinstall from a clean node_modules.

setCount reverts with 0x7ba5ffb5

The input signature binds the encrypting account and the consuming contract. The call reverts when a different wallet sends the transaction, or when setConsumingContract named a different contract. viem reports the revert by its selector, 0x7ba5ffb5, which is InvalidSigner(address,address).

encryptInputs has no execute method

The SDK types only offer execute() after setConsumingContract(), so TypeScript reports Property 'execute' does not exist. At runtime, the same omission throws CONSUMING_CONTRACT_UNINITIALIZED.

A second operation reverts with 0x4d13139e

The contract did not call FHE.allowThis on a stored handle, so its next transaction cannot use it. viem reports the revert by its selector, 0x4d13139e, which is ACLNotAllowed(uint256,address). Wrap the call in withLogs to see which grants each operation made.

Hardhat 2 plugin testing: the same patterns with Mocha and ethers.
Decrypt to transact: the full decryptForTx guide.

Introduction

Quick Start

Guides

Hardhat Plugin

Hardhat 3 Plugin

Foundry Plugin

Examples

Reference

The contract

Encrypt, store, and decrypt

Start each test from a clean chain

Assert on plaintext

Named ACPs

Decrypt for a transaction

Public handles

Handles restricted by the ACL

Publish the result onchain

Common pitfalls

​The contract

​Encrypt, store, and decrypt

​Start each test from a clean chain

​Assert on plaintext

​Named ACPs

​Decrypt for a transaction

​Public handles

​Handles restricted by the ACL

​Publish the result onchain

​Common pitfalls

​Related

The contract

Encrypt, store, and decrypt

Start each test from a clean chain

Assert on plaintext

Named ACPs

Decrypt for a transaction

Public handles

Handles restricted by the ACL

Publish the result onchain

Common pitfalls

Related