Conditions (if .. else)

Understanding why if..else isn’t possible with FHE and exploring the alternatives

Overview

Writing smart contracts with Fully Homomorphic Encryption (FHE) changes how you handle conditionals. Since all data is encrypted, you can’t use traditional if...else statementsthere’s no way to view the values being compared.

Moreover, conditionals in FHE must evaluate both branches simultaneously. This is similar to constant-time cryptographic programming, where branching can leak information through timing attacksfor example, if one path takes longer to execute, an observer could infer which condition was true.

Using traditional if...else on encrypted data might result in unexpected behavior and leak information about your encrypted values.

---

The Select Function

To handle encrypted conditionals, Fhenix uses a concept called a selectora function that takes an encrypted condition and two possible values, returning one based on the encrypted result.

In practice, this is done with the select function. It behaves like a ternary operator (condition ? a : b) but works entirely on encrypted data.

How It Works

FHE.select takes the encrypted ebool returned by comparison operations like gt. If the condition represents encrypted true, it returns the first value; otherwise, it returns the second valueall without revealing which path was taken.

---

Quick Start

Don't Do This

euint32 a = FHE.asEuint32(10);
euint32 b = FHE.asEuint32(20);
euint32 max;

// This won't work as expected!
if (a.gt(b)) { // gt returns encrypted boolean (ebool)
   max = a;    // Traditional if..else leaks information
} else {
   max = b;
}

euint32 a = FHE.asEuint32(10);
euint32 b = FHE.asEuint32(20);

// Use select for encrypted conditionals
ebool isHigher = a.gt(b);
euint32 max = FHE.select(isHigher, a, b);

---

Key Points to Remember

Encrypted Operations Only

All operations take place on encrypted data, so the actual values and comparison results stay concealed from observers.

No Traditional Branching

Traditional if...else statements on encrypted data leak information through execution paths and timing.

Select is Your Friend

The select function is the only way to handle conditional execution in FHE without leaking information.

Both Paths Execute

Both branches are evaluated, then the correct result is selected based on the encrypted condition.

---

Common Use Cases

Here are some common scenarios where you’ll use select:

1. Maximum/Minimum Operations

Find the larger or smaller of two encrypted values:

// Maximum
euint32 max = FHE.select(a.gt(b), a, b);

// Minimum
euint32 min = FHE.select(a.lt(b), a, b);

2. Conditional Updates

Update a value only when a condition is met:

ebool shouldUpdate = checkCondition();
euint32 newValue = FHE.select(shouldUpdate, updatedValue, currentValue);

// Store the result (either updated or unchanged)
_storedValue = newValue;

3. Threshold Checks

Cap values at a certain threshold:

ebool isAboveThreshold = value.gt(threshold);
euint32 result = FHE.select(isAboveThreshold, threshold, value);

// Result will be capped at threshold if value exceeds it

4. Conditional Access Control

Grant different permissions based on encrypted conditions:

ebool hasPermission = userRole.eq(ADMIN_ROLE);
euint32 accessLevel = FHE.select(hasPermission, FULL_ACCESS, LIMITED_ACCESS);

5. Fee Calculations

Apply different rates based on encrypted criteria:

ebool isPremiumUser = userTier.gt(STANDARD_TIER);
euint32 feeRate = FHE.select(isPremiumUser, PREMIUM_FEE, STANDARD_FEE);
euint32 totalFee = FHE.mul(amount, feeRate);

---

Best Practices

Always Use Select for Conditionals

Never try to implement branching logic with traditional if...else statements on encrypted data. Always use select to ensure constant-time execution and prevent information leakage.

// Good
euint32 result = FHE.select(condition, valueA, valueB);

// Bad - don't publish decrypted values for branching logic!
FHE.publishDecryptResult(condition, plaintext, signature); // Don't do this!
if (plaintext > 0) {
    result = valueA;
} else {
    result = valueB;
}

Keep Conditional Logic Simple and Linear

Complex nested conditions should be broken down into simpler operations. Each select can only choose between two values, so chain them carefully.

// For multiple conditions, chain select operations
ebool condition1 = a.gt(b);
ebool condition2 = c.lt(d);

euint32 temp = FHE.select(condition1, valueA, valueB);
euint32 final = FHE.select(condition2, temp, valueC);

Remember All Operations Are on Encrypted Data

Every value, comparison, and result remains encrypted throughout the entire process. The blockchain never sees plaintext values.

ebool condition = encryptedValue.gt(encryptedThreshold); // Encrypted comparison
euint32 result = FHE.select(condition, encA, encB);      // Encrypted selection
// Both condition and result remain encrypted

Consider Performance Implications

Since both branches of a select are always evaluated, complex operations in both paths will always execute. Structure your code to minimize unnecessary computations.

// Both computations happen regardless of condition
euint32 expensiveA = complexOperation(a);
euint32 expensiveB = complexOperation(b);
euint32 result = FHE.select(condition, expensiveA, expensiveB);

// Consider pre-computing when possible

---

Complete Example: Auction Bid

Here’s a practical example showing how to handle encrypted bids in an auction:

contract EncryptedAuction {
    euint32 public highestBid;
    address public highestBidder;

    function placeBid(InEuint32 memory encryptedBid) public {
        euint32 bid = FHE.asEuint32(encryptedBid);

        // Compare new bid with current highest (encrypted comparison)
        ebool isHigher = bid.gt(highestBid);

        // Update highest bid using select
        euint32 newHighestBid = FHE.select(isHigher, bid, highestBid);

        // Grant contract access to the new highest bid
        FHE.allowThis(newHighestBid);

        highestBid = newHighestBid;

        // Update highest bidder (note: address is not encrypted)
        // In production, you'd handle this more carefully
        if (/* some non-encrypted condition */) {
            highestBidder = msg.sender;
        }
    }

    function revealWinner(euint32 ctHash, uint32 plaintext, bytes calldata signature) public {
        // Verify and publish the decrypted highest bid on-chain
        FHE.publishDecryptResult(ctHash, plaintext, signature);
    }
}

In the example above, the actual bid amounts remain encrypted throughout the auction. To reveal the winner, a client calls decryptForTx off-chain to obtain the plaintext and a threshold signature, then submits them on-chain via revealWinner for verification.

---

Related Topics

• Learn more about comparison operations in FHE Encrypted Operations
• Understand how to manage access in Access Control