Supported Types and Operations
The library exposes utility functions for FHE operations. The goal of the library is to provide a seamless developer experience for writing smart contracts that can operate on confidential data.
Typesβ
The library provides a type system that is checked both at compile time and at run time. The structure and operations related to these types are described in this sections.
We currently support encrypted integers of bit length up to 256 bits and special types such as ebool
and eaddress
.
The encrypted integers behave as much as possible as Solidity's integer types. However, behaviour such as "revert on overflow" is not supported as this would leak some information of the encrypted integers. Therefore, arithmetic on euint
types is unchecked, i.e. there is wraparound on overlow.
In the backend, encrypted integers are FHE ciphertexts. The library abstracts away the ciphertexts and presents pointers to ciphertexts, or ciphertext handles, to the smart contract developer. The euint
, ebool
and eaddress
types are wrappers over these handles.
Supported types  



Operationsβ
There are three ways to perform operations with FHE.sol:
Using Direct Function Callsβ
Direct function calls are the most straightforward way to perform operations with FHE.sol. For example, if you want to add two encrypted 8bit integers (euint8), you can do so as follows:
euint8 result = FHE.add(lhs, rhs);
Here, lhs and rhs are your euint8 variables, and result will store the outcome of the addition.
Using Library Bindingsβ
FHE.sol also provides library bindings, allowing for a more natural syntax. To use this, you first need to include the library for your specific data type. For euint8, the usage would look like this:
euint8 result = lhs.add(rhs);
In this example, lhs.add(rhs) performs the addition, using the library function implicitly.
Utilizing Operator Overloadingβ
For an even more intuitive approach, FHE.sol supports operator overloading. This means you can use standard arithmetic operators like +, , *, etc., directly on encrypted types. Here's how you can use it for adding two euint8 values:
euint8 result = lhs + rhs;
With operator overloading, lhs + rhs performs the addition seamlessly.
Comparisonsβ
Unlike other operations in FHE.sol, comparison operations do not support their respective operators (e.g. >
, <
etc.).
This is because solidity expects these operators to return a boolean value, which is not possible with FHE.
Intuitively, this is because returning a boolean value would leak information about the encrypted data.
Instead, comparison operations are implemented as functions that return an ebool
type.
The ebool
type is not a real boolean type. It is implemented as a euint8
Supported Operationsβ
A documented documentation of each and every function in FHE.sol (including inputs and outputs) can be found in FHE.sol
All operations supported by FHE.sol are listed in the table below. For performance reasons, not all operations are supported for all types.
Please refer to the table below for a comprehensive list of supported operations. This list will evolve as the network matures.
Note that all functions are supported in both direct function calls and library bindings. However, operator overloading is only supported for the operations listed in the table (solidity please support operator overloading for boolean return types!).
name  FHE.sol function  Operator  euint8  euint16  euint32  euint64  euint128  euint256  ebool  eaddress 

Addition  add  +  β  β  β  β  β  n/a  n/a  n/a 
Subtraction  sub    β  β  β  β  β  n/a  n/a  n/a 
Multiplication  mul  *  β  β  β  β  x  n/a  n/a  n/a 
Bitwise And  and  &  β  β  β  β  β  n/a  β  n/a 
Bitwise Or  or    β  β  β  β  β  n/a  β  n/a 
Bitwise Xor  xor  ^  β  β  β  β  β  n/a  β  n/a 
Division  div  /  β  β  β  x  x  n/a  n/a  n/a 
Remainder  rem  %  β  β  β  x  x  n/a  n/a  n/a 
Shift Right  shr  n/a  β  β  β  β  β  n/a  n/a  n/a 
Shift Left  shl  n/a  β  β  β  β  β  n/a  n/a  n/a 
Equal  eq  n/a  β  β  β  β  β  β  β  β 
Not equal  ne  n/a  β  β  β  β  β  β  β  β 
Greater than or equal  gte  n/a  β  β  β  β  β  n/a  n/a  n/a 
Greater than  gt  n/a  β  β  β  β  β  n/a  n/a  n/a 
Less than or equal  lte  n/a  β  β  β  β  β  n/a  n/a  n/a 
Less than  lt  n/a  β  β  β  β  β  n/a  n/a  n/a 
Min  min  n/a  β  β  β  β  β  n/a  n/a  n/a 
Max  max  n/a  β  β  β  β  β  n/a  n/a  n/a 
Not  not  n/a  β  β  β  β  β  n/a  β  n/a 
Select  select  n/a  β  β  β  β  β  β  β  β 
Require  req  n/a  β  β  β  β  β  β  β  β 
Decrypt  decrypt  n/a  β  β  β  β  β  β  β  β 
Seal Output  sealOutput  n/a  β  β  β  β  β  β  β  β 
At the moment it is not possible to do ebool result = (lhs == rhs)
and others that return a boolean result. This is because FHE.sol expects a ebool
, while Solidity only allows overloading to return a regular boolean.
Instead, we recommend ebool result = lhs.eq(rhs)
.
Using require and decrypt in a TX is dangerous as it can break the confidentiality of the data. Please refer to UsefulTips to read some more
Division and Remainder by 0
will output with an encrypted representation of the maximal value of the uint that is used (Ex. encrypted 255 for euint8)