Encrypt Multiple Values

Efficient handling of multiple encrypted values via batched inputs. Uses a single proof for multiple values (ebool, euint32, eaddress), saving significant gas compared to separate proofs.

To run this example correctly, make sure the files are placed in the following directories:

.sol file → <your-project-root-dir>/contracts/
.ts file → <your-project-root-dir>/test/

This ensures Hardhat can compile and test your contracts as expected.

🔐 FHE API Reference (9 items)

Types: eaddress · ebool · euint32 · externalEaddress · externalEbool · externalEuint32

Functions:

FHE.allow() - Grants PERMANENT permission for address to decrypt/use value
FHE.allowThis() - Grants contract permission to operate on ciphertext
FHE.fromExternal() - Validates and converts external encrypted input using inputProof

// SPDX-License-Identifier: BSD-3-Clause-Clear
pragma solidity ^0.8.24;

import {
    FHE,
    externalEbool,
    externalEuint32,
    externalEaddress,
    ebool,
    euint32,
    eaddress
} from "@fhevm/solidity/lib/FHE.sol";
import {ZamaEthereumConfig} from "@fhevm/solidity/config/ZamaConfig.sol";

/**
 * @notice Efficient handling of multiple encrypted values via batched inputs.
 *         Uses a single proof for multiple values (ebool, euint32, eaddress),
 *         saving significant gas compared to separate proofs.
 *
 * @dev Batching saves ~50k gas per additional value.
 */
contract EncryptMultipleValues is ZamaEthereumConfig {
    ebool private _encryptedEbool;
    euint32 private _encryptedEuint32;
    eaddress private _encryptedEaddress;

    /// @notice Store multiple encrypted values from single batched input
    /// @dev Client creates ONE proof for ALL values using createEncryptedInput().
    ///      Much cheaper than separate encrypt() calls!
    function initialize(
        externalEbool inputEbool,
        externalEuint32 inputEuint32,
        externalEaddress inputEaddress,
        bytes calldata inputProof // Single proof covers all!
    ) external {
        // 💡 Why one proof? Client batches all values before encrypt()
        // Saves ~50k gas per additional value!
        _encryptedEbool = FHE.fromExternal(inputEbool, inputProof);
        _encryptedEuint32 = FHE.fromExternal(inputEuint32, inputProof);
        _encryptedEaddress = FHE.fromExternal(inputEaddress, inputProof);

        // 🔐 Each value needs own permissions (no batching here)
        FHE.allowThis(_encryptedEbool);
        FHE.allow(_encryptedEbool, msg.sender);

        FHE.allowThis(_encryptedEuint32);
        FHE.allow(_encryptedEuint32, msg.sender);

        FHE.allowThis(_encryptedEaddress);
        FHE.allow(_encryptedEaddress, msg.sender);
    }

    function encryptedBool() public view returns (ebool) {
        return _encryptedEbool;
    }

    function encryptedUint32() public view returns (euint32) {
        return _encryptedEuint32;
    }

    function encryptedAddress() public view returns (eaddress) {
        return _encryptedEaddress;
    }
}

import {
  EncryptMultipleValues,
  EncryptMultipleValues__factory,
} from "../types";
import {
  FhevmType,
  HardhatFhevmRuntimeEnvironment,
} from "@fhevm/hardhat-plugin";
import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
import { expect } from "chai";
import { ethers } from "hardhat";
import * as hre from "hardhat";

/** Common signers interface */
interface Signers {
  owner: HardhatEthersSigner;
  alice: HardhatEthersSigner;
}

async function deployFixture() {
  // Contracts are deployed using the first signer/account by default
  const factory = (await ethers.getContractFactory(
    "EncryptMultipleValues"
  )) as EncryptMultipleValues__factory;
  const encryptMultipleValues =
    (await factory.deploy()) as EncryptMultipleValues;
  const encryptMultipleValues_address =
    await encryptMultipleValues.getAddress();

  return { encryptMultipleValues, encryptMultipleValues_address };
}

/**
 * Encrypt Multiple Values Tests
 *
 * Tests the FHE encryption mechanism for multiple values in a single transaction.
 * Validates handle binding and zero-knowledge proof verification for batched inputs.
 */
describe("EncryptMultipleValues", function () {
  let contract: EncryptMultipleValues;
  let contractAddress: string;
  let signers: Signers;

  before(async function () {
    // Check whether the tests are running against an FHEVM mock environment
    if (!hre.fhevm.isMock) {
      throw new Error(`This hardhat test suite cannot run on Sepolia Testnet`);
    }

    const ethSigners: HardhatEthersSigner[] = await ethers.getSigners();
    signers = { owner: ethSigners[0], alice: ethSigners[1] };
  });

  beforeEach(async function () {
    // Deploy a new contract each time we run a new test
    const deployment = await deployFixture();
    contractAddress = deployment.encryptMultipleValues_address;
    contract = deployment.encryptMultipleValues;
  });

  // ✅ Test should succeed
  it("encryption should succeed", async function () {
    // Use the FHEVM Hardhat plugin runtime environment
    // to perform FHEVM input encryptions.
    const fhevm: HardhatFhevmRuntimeEnvironment = hre.fhevm;

    // 🔐 Encryption Process:
    // Create an encrypted input bound to this contract and Alice.
    const input = fhevm.createEncryptedInput(
      contractAddress,
      signers.alice.address
    );

    // Add multiple values of different types to the same input object.
    input.addBool(true);
    input.add32(123456);
    input.addAddress(signers.owner.address);

    // Perform the local encryption.
    // This produces:
    // - `handles`: an array where each index corresponds to the value added above.
    // - `inputProof`: a single ZKP that validates ALL handles in this input.
    const enc = await input.encrypt();

    const inputEbool = enc.handles[0]; // Handle for the boolean
    const inputEuint32 = enc.handles[1]; // Handle for the uint32
    const inputEaddress = enc.handles[2]; // Handle for the address
    const inputProof = enc.inputProof;

    // 🚀 Submit the transaction:
    // We pass all handles and the single input proof.
    const tx = await contract
      .connect(signers.alice)
      .initialize(inputEbool, inputEuint32, inputEaddress, inputProof);
    await tx.wait();

    // 🔓 Verification:
    const encryptedBool = await contract.encryptedBool();
    const encryptedUint32 = await contract.encryptedUint32();
    const encryptedAddress = await contract.encryptedAddress();

    // Use specific decryption helpers for each FHE type.
    const clearBool = await fhevm.userDecryptEbool(
      encryptedBool,
      contractAddress,
      signers.alice
    );

    const clearUint32 = await fhevm.userDecryptEuint(
      FhevmType.euint32,
      encryptedUint32,
      contractAddress,
      signers.alice
    );

    const clearAddress = await fhevm.userDecryptEaddress(
      encryptedAddress,
      contractAddress,
      signers.alice
    );

    expect(clearBool).to.equal(true);
    expect(clearUint32).to.equal(123456);
    expect(clearAddress).to.equal(signers.owner.address);
  });
});

PreviousEncrypt Single Value NextDecryption

Last updated 17 days ago

import { EncryptMultipleValues, EncryptMultipleValues__factory, } from "../types"; import { FhevmType, HardhatFhevmRuntimeEnvironment, } from "@fhevm/hardhat-plugin"; import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers"; import { expect } from "chai"; import { ethers } from "hardhat"; import * as hre from "hardhat"; /** Common signers interface */ interface Signers { owner: HardhatEthersSigner; alice: HardhatEthersSigner; } async function deployFixture() { // Contracts are deployed using the first signer/account by default const factory = (await ethers.getContractFactory( "EncryptMultipleValues" )) as EncryptMultipleValues__factory; const encryptMultipleValues = (await factory.deploy()) as EncryptMultipleValues; const encryptMultipleValues_address = await encryptMultipleValues.getAddress(); return { encryptMultipleValues, encryptMultipleValues_address }; } /** * Encrypt Multiple Values Tests * * Tests the FHE encryption mechanism for multiple values in a single transaction. * Validates handle binding and zero-knowledge proof verification for batched inputs. */ describe("EncryptMultipleValues", function () { let contract: EncryptMultipleValues; let contractAddress: string; let signers: Signers; before(async function () { // Check whether the tests are running against an FHEVM mock environment if (!hre.fhevm.isMock) { throw new Error(`This hardhat test suite cannot run on Sepolia Testnet`); } const ethSigners: HardhatEthersSigner[] = await ethers.getSigners(); signers = { owner: ethSigners[0], alice: ethSigners[1] }; }); beforeEach(async function () { // Deploy a new contract each time we run a new test const deployment = await deployFixture(); contractAddress = deployment.encryptMultipleValues_address; contract = deployment.encryptMultipleValues; }); // ✅ Test should succeed it("encryption should succeed", async function () { // Use the FHEVM Hardhat plugin runtime environment // to perform FHEVM input encryptions. const fhevm: HardhatFhevmRuntimeEnvironment = hre.fhevm; // 🔐 Encryption Process: // Create an encrypted input bound to this contract and Alice. const input = fhevm.createEncryptedInput( contractAddress, signers.alice.address ); // Add multiple values of different types to the same input object. input.addBool(true); input.add32(123456); input.addAddress(signers.owner.address); // Perform the local encryption. // This produces: // - `handles`: an array where each index corresponds to the value added above. // - `inputProof`: a single ZKP that validates ALL handles in this input. const enc = await input.encrypt(); const inputEbool = enc.handles[0]; // Handle for the boolean const inputEuint32 = enc.handles[1]; // Handle for the uint32 const inputEaddress = enc.handles[2]; // Handle for the address const inputProof = enc.inputProof; // 🚀 Submit the transaction: // We pass all handles and the single input proof. const tx = await contract .connect(signers.alice) .initialize(inputEbool, inputEuint32, inputEaddress, inputProof); await tx.wait(); // 🔓 Verification: const encryptedBool = await contract.encryptedBool(); const encryptedUint32 = await contract.encryptedUint32(); const encryptedAddress = await contract.encryptedAddress(); // Use specific decryption helpers for each FHE type. const clearBool = await fhevm.userDecryptEbool( encryptedBool, contractAddress, signers.alice ); const clearUint32 = await fhevm.userDecryptEuint( FhevmType.euint32, encryptedUint32, contractAddress, signers.alice ); const clearAddress = await fhevm.userDecryptEaddress( encryptedAddress, contractAddress, signers.alice ); expect(clearBool).to.equal(true); expect(clearUint32).to.equal(123456); expect(clearAddress).to.equal(signers.owner.address); }); });

Good afternoon