fhenix-client-sdk-encryption

---
name: fhenix-client-sdk-encryption
description: Encrypt plaintext into InE* inputs with @cofhe/sdk encryptInputs + the Encryptable factory, then pass them into a contract call. Covers the 5-step ZK pipeline, the 2048-bit limit, builder options (setAccount/setChainId/onStep), and the EncryptedItemInput shape.
license: MIT
---

# Fhenix Client SDK — Encrypting Inputs

## Overview
Values must be encrypted client-side before going on-chain. `encryptInputs([...])` takes `Encryptable.*` items, runs a ZK-proven encryption pipeline, and returns a typed tuple of `EncryptedItemInput` objects that map 1:1 to your contract's `InE*` struct parameters. The on-chain CoFHE library verifies each item's signature before using the ciphertext.

## Encrypt and call a contract
```typescript
import { Encryptable, assertCorrectEncryptedItemInput } from '@cofhe/sdk';

await cofheClient.connect(publicClient, walletClient);

const [inCount] = await cofheClient
  .encryptInputs([Encryptable.uint32(42n)])
  .execute();
assertCorrectEncryptedItemInput(inCount);

await contract.setCount(inCount); // Solidity: function setCount(InEuint32 _in)
```
A multi-value example returns a typed tuple mirroring the input array:
```typescript
const [eUint32, eBool, eAddress] = await cofheClient.encryptInputs([
  Encryptable.uint32(42n),
  Encryptable.bool(true),
  Encryptable.address('0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045'),
]).execute();
```

## Encryptable factory — type must match the Solidity param
| Factory | Value type | Solidity input |
| --- | --- | --- |
| `Encryptable.bool(v)` | `boolean` | `InEbool` |
| `Encryptable.uint8/16/32/64/128(v)` | `bigint \| string` | `InEuint8…128` |
| `Encryptable.address(v)` | `bigint \| string` | `InEaddress` |

Generic form: `Encryptable.create('uint32', 42n)`.

## The 5-step pipeline (what `.execute()` runs)
| Step | Description |
| --- | --- |
| `InitTfhe` | Lazy-init the TFHE WASM (no-op after first call) |
| `FetchKeys` | Fetch/cache FHE public key + CRS for the chain |
| `Pack` | Pack plaintext into a ZK list |
| `Prove` | Generate the zero-knowledge proof (ZKPoK); uses a Web Worker when available |
| `Verify` | Send proof to the CoFHE verifier; returns signed `EncryptedItemInput`s |

## Builder options
- `.execute()` — required, call last; returns `EncryptedItemInput[]`.
- `.setAccount(address)` — which address "owns"/may use the inputs on-chain (default: connected wallet).
- `.setChainId(chainId)` — target chain (default: connected chain).
- `.setUseWorker(bool)` — override Web Worker proving (default true; no-op in Node).
- `.onStep((step, ctx) => …)` — progress callback (`ctx.isStart`/`ctx.isEnd`/`ctx.duration`).

## EncryptedItemInput (result shape)
```typescript
type EncryptedItemInput = {
  ctHash: bigint;        // ciphertext hash registered with CoFHE
  securityZone: number;  // security zone used
  utype: FheTypes;       // Bool, Uint8…Uint160
  signature: string;     // CoFHE verifier signature authorizing this input
};
```
If hand-writing an ABI, the tuple order is `(ctHash, securityZone, utype, signature)`.

## Common pitfalls
- **Wrong `Encryptable` type** vs the Solidity `InE*` param (`uint32` vs `uint64`).
- **Wrong account/chain** — inputs are authorized for a specific `account + chainId`; overriding them can make the tx revert.
- **Bit limit** — a single `encryptInputs` call encrypts at most **2048 bits** total; exceeding throws `ZkPackFailed` (split into multiple calls).

## Source docs
- [`client-sdk/guides/encrypting-inputs.mdx`](../fhenix-docs/client-sdk/guides/encrypting-inputs.mdx)
- [`client-sdk/guides/writing-encrypted-data.mdx`](../fhenix-docs/client-sdk/guides/writing-encrypted-data.mdx)

## AI Agent Prompt
> "Encrypt a `uint64` amount and an `address` with `encryptInputs`, asserting the result, and call a `confidentialTransfer(address,InEuint64)` contract function via viem — handling the 2048-bit limit if more values are added."