create-fhevm-example 1.4.3 → 1.4.5

package/contracts/basic/fhe-operations/FHEAdd.sol

@@ -5,21 +5,23 @@ import {FHE, euint8, externalEuint8} from "@fhevm/solidity/lib/FHE.sol";
 import {ZamaEthereumConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
 
 /**
- * @notice Simple example: adding two encrypted values (a + b)
- *
- * @dev Demonstrates the most basic FHE operation and permission flow.
+ * @notice Introduction to homomorphic addition on encrypted values.
+ *         Demonstrates the most fundamental FHE operation: adding two encrypted
+ *         numbers without decrypting them. Shows the complete flow from receiving
+ *         encrypted inputs, performing the addition, and granting permissions
+ *         for both contract storage and user decryption.
+
+ * @dev Shows the most basic FHE operation and permission flow.
+ *      ⚡ Gas: FHE.add() costs ~100k gas (coprocessor call)
  */
 contract FHEAdd is ZamaEthereumConfig {
     euint8 private _a;
     euint8 private _b;
     euint8 private _result;
 
-    constructor() {}
-
     /// @notice Set the first operand (encrypted)
     function setA(externalEuint8 inputA, bytes calldata inputProof) external {
         _a = FHE.fromExternal(inputA, inputProof);
-        // Only contract needs permission to use this for computation
         FHE.allowThis(_a);
     }
 
@@ -30,21 +32,17 @@ contract FHEAdd is ZamaEthereumConfig {
     }
 
     /// @notice Compute a + b on encrypted values
-    /// @dev The contract computes on ciphertexts - it never sees actual values!
+    /// @dev Contract operates on ciphertexts - never sees actual values!
     function computeAPlusB() external {
-        // 🔐 Addition on encrypted values
-        // Neither the contract nor anyone else knows what a, b, or result are
+        // 🧮 Homomorphic: operates on encrypted data without decrypting
         _result = FHE.add(_a, _b);
 
-        // 📋 PERMISSION FLOW:
-        // During this function, contract has "ephemeral" permission on _result
-        // When function ends, ephemeral permission is revoked
-        // We need PERMANENT permissions for future access:
-        FHE.allowThis(_result); // Contract can use result later
-        FHE.allow(_result, msg.sender); // Caller can decrypt result
+        // 🔑 Why both? allowThis = contract can use it, allow = user can decrypt
+        FHE.allowThis(_result);
+        FHE.allow(_result, msg.sender);
     }
 
-    /// @notice Returns the encrypted result
+    /// @notice Returns the encrypted result handle
     function result() public view returns (euint8) {
         return _result;
     }

package/contracts/basic/fhe-operations/FHEArithmetic.sol

@@ -5,93 +5,81 @@ import {FHE, euint32, externalEuint32} from "@fhevm/solidity/lib/FHE.sol";
 import {ZamaEthereumConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
 
 /**
- * @notice Demonstrates all FHE arithmetic operations on encrypted integers
+ * @notice Complete suite of FHE arithmetic operations on encrypted values.
+ *         Covers all basic math: addition, subtraction, multiplication, division,
+ *         remainder (modulo), minimum, and maximum. Includes gas cost comparisons
+ *         and important limitations (e.g., division/remainder only work with
+ *         plaintext divisors, not encrypted divisors).
  *
- * @dev This contract shows how to perform mathematical operations on encrypted values
- *      without ever revealing the underlying data.
- *
- * Available operations:
- * - FHE.add(a, b)  : Addition
- * - FHE.sub(a, b)  : Subtraction
- * - FHE.mul(a, b)  : Multiplication
- * - FHE.div(a, b)  : Division (integer)
- * - FHE.rem(a, b)  : Remainder (modulo)
- * - FHE.min(a, b)  : Minimum of two values
- * - FHE.max(a, b)  : Maximum of two values
+ * @dev ⚡ Gas costs vary: add/sub (~100k) < mul (~150k) < div/rem (~300k)
+ *      ⚠️ div/rem only work with plaintext divisor (not encrypted!)
  */
 contract FHEArithmetic is ZamaEthereumConfig {
     euint32 private _a;
     euint32 private _b;
     euint32 private _result;
 
-    // solhint-disable-next-line no-empty-blocks
-    constructor() {}
-
-    /// @notice Sets the first operand (encrypted)
     function setA(externalEuint32 inputA, bytes calldata inputProof) external {
         _a = FHE.fromExternal(inputA, inputProof);
         FHE.allowThis(_a);
     }
 
-    /// @notice Sets the second operand (encrypted)
     function setB(externalEuint32 inputB, bytes calldata inputProof) external {
         _b = FHE.fromExternal(inputB, inputProof);
         FHE.allowThis(_b);
     }
 
-    /// @notice Computes encrypted addition: result = a + b
+    /// @notice Encrypted addition: result = a + b
     function computeAdd() external {
         _result = FHE.add(_a, _b);
         _grantPermissions();
     }
 
-    /// @notice Computes encrypted subtraction: result = a - b
-    /// @dev No underflow protection - in production, add range checks
+    /// @notice Encrypted subtraction: result = a - b
+    /// @dev ⚠️ No underflow protection! Wraps around at 0.
     function computeSub() external {
         _result = FHE.sub(_a, _b);
         _grantPermissions();
     }
 
-    /// @notice Computes encrypted multiplication: result = a * b
-    /// @dev No overflow protection - in production, add range checks
+    /// @notice Encrypted multiplication: result = a * b
+    /// @dev ⚠️ No overflow protection! May wrap at type max.
     function computeMul() external {
         _result = FHE.mul(_a, _b);
         _grantPermissions();
     }
 
-    /// @notice Computes encrypted division: result = a / b (scalar)
-    /// @dev Divisor must be a scalar (plaintext) because FHE division by encrypted value is not supported.
+    /// @notice Encrypted division: result = a / divisor
+    /// @dev ❌ WRONG: FHE.div(encryptedA, encryptedB) - not supported!
+    ///      ✅ CORRECT: FHE.div(encryptedA, plaintextB)
     function computeDiv(uint32 divisor) external {
         _result = FHE.div(_a, divisor);
         _grantPermissions();
     }
 
-    /// @notice Computes encrypted remainder: result = a % b (scalar)
-    /// @dev Divisor must be a scalar (plaintext).
+    /// @notice Encrypted remainder: result = a % modulus
+    /// @dev Modulus must be plaintext (same limitation as div)
     function computeRem(uint32 modulus) external {
         _result = FHE.rem(_a, modulus);
         _grantPermissions();
     }
 
-    /// @notice Computes encrypted minimum: result = min(a, b)
+    /// @notice Encrypted minimum: result = min(a, b)
     function computeMin() external {
         _result = FHE.min(_a, _b);
         _grantPermissions();
     }
 
-    /// @notice Computes encrypted maximum: result = max(a, b)
+    /// @notice Encrypted maximum: result = max(a, b)
     function computeMax() external {
         _result = FHE.max(_a, _b);
         _grantPermissions();
     }
 
-    /// @notice Returns the encrypted result
-    /// @dev Caller must have FHE permissions to decrypt
     function getResult() public view returns (euint32) {
         return _result;
     }
 
-    /// @dev Grants FHE permissions to contract and caller for decryption
     function _grantPermissions() internal {
         FHE.allowThis(_result);
         FHE.allow(_result, msg.sender);

package/contracts/basic/fhe-operations/FHEComparison.sol

@@ -10,19 +10,15 @@ import {
 import {ZamaEthereumConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
 
 /**
- * @notice Demonstrates all FHE comparison operations on encrypted integers
+ * @notice Complete guide to encrypted comparisons and conditional selection.
+ *         Covers all comparison operators (eq, ne, gt, lt, ge, le) that return
+ *         encrypted booleans (ebool), and demonstrates FHE.select for branching
+ *         without information leakage. Critical for implementing logic like
+ *         "find maximum" or "check threshold" without revealing values.
  *
- * @dev This contract shows how to compare encrypted values without decrypting them.
- *      Comparison results are returned as encrypted booleans (ebool).
- *
- * Available operations:
- * - FHE.eq(a, b)   : Equal (a == b)
- * - FHE.ne(a, b)   : Not equal (a != b)
- * - FHE.gt(a, b)   : Greater than (a > b)
- * - FHE.lt(a, b)   : Less than (a < b)
- * - FHE.ge(a, b)   : Greater or equal (a >= b)
- * - FHE.le(a, b)   : Less or equal (a <= b)
- * - FHE.select(cond, a, b) : Conditional selection (cond ? a : b)
+ * @dev Results are encrypted booleans (ebool) - comparisons reveal nothing!
+ *      ⚡ Gas: Comparisons ~100k, select ~120k
+ *      ❌ WRONG: if (FHE.gt(a,b)) → decrypts! ✅ CORRECT: FHE.select()
  */
 contract FHEComparison is ZamaEthereumConfig {
     euint32 private _a;
@@ -30,67 +26,57 @@ contract FHEComparison is ZamaEthereumConfig {
     ebool private _boolResult;
     euint32 private _selectedResult;
 
-    // solhint-disable-next-line no-empty-blocks
-    constructor() {}
-
-    /// @notice Sets the first operand (encrypted)
     function setA(externalEuint32 inputA, bytes calldata inputProof) external {
         _a = FHE.fromExternal(inputA, inputProof);
         FHE.allowThis(_a);
     }
 
-    /// @notice Sets the second operand (encrypted)
     function setB(externalEuint32 inputB, bytes calldata inputProof) external {
         _b = FHE.fromExternal(inputB, inputProof);
         FHE.allowThis(_b);
     }
 
-    /// @notice Computes encrypted equality: result = (a == b)
     function computeEq() external {
         _boolResult = FHE.eq(_a, _b);
         _grantBoolPermissions();
     }
 
-    /// @notice Computes encrypted inequality: result = (a != b)
     function computeNe() external {
         _boolResult = FHE.ne(_a, _b);
         _grantBoolPermissions();
     }
 
-    /// @notice Computes encrypted greater than: result = (a > b)
     function computeGt() external {
         _boolResult = FHE.gt(_a, _b);
         _grantBoolPermissions();
     }
 
-    /// @notice Computes encrypted less than: result = (a < b)
     function computeLt() external {
         _boolResult = FHE.lt(_a, _b);
         _grantBoolPermissions();
     }
 
-    /// @notice Computes encrypted greater or equal: result = (a >= b)
     function computeGe() external {
         _boolResult = FHE.ge(_a, _b);
         _grantBoolPermissions();
     }
 
-    /// @notice Computes encrypted less or equal: result = (a <= b)
     function computeLe() external {
         _boolResult = FHE.le(_a, _b);
         _grantBoolPermissions();
     }
 
-    /// @notice Computes encrypted maximum using select: result = (a > b) ? a : b
-    /// @dev Demonstrates FHE.select for conditional logic on encrypted values
+    /// @notice Encrypted maximum using select: (a > b) ? a : b
+    /// @dev 🔀 Why select? Using if(aGtB) would decrypt and leak the comparison!
     function computeMaxViaSelect() external {
         ebool aGtB = FHE.gt(_a, _b);
+        // select evaluates both branches, picks one without revealing which
         _selectedResult = FHE.select(aGtB, _a, _b);
         FHE.allowThis(_selectedResult);
         FHE.allow(_selectedResult, msg.sender);
     }
 
-    /// @notice Computes encrypted minimum using select: result = (a < b) ? a : b
+    /// @notice Encrypted minimum using select: (a < b) ? a : b
     function computeMinViaSelect() external {
         ebool aLtB = FHE.lt(_a, _b);
         _selectedResult = FHE.select(aLtB, _a, _b);
@@ -98,17 +84,14 @@ contract FHEComparison is ZamaEthereumConfig {
         FHE.allow(_selectedResult, msg.sender);
     }
 
-    /// @notice Returns the encrypted boolean result
     function getBoolResult() public view returns (ebool) {
         return _boolResult;
     }
 
-    /// @notice Returns the encrypted selected result
     function getSelectedResult() public view returns (euint32) {
         return _selectedResult;
     }
 
-    /// @dev Grants FHE permissions for boolean result
     function _grantBoolPermissions() internal {
         FHE.allowThis(_boolResult);
         FHE.allow(_boolResult, msg.sender);

package/contracts/basic/fhe-operations/FHEIfThenElse.sol

@@ -5,17 +5,20 @@ import {FHE, ebool, euint8, externalEuint8} from "@fhevm/solidity/lib/FHE.sol";
 import {ZamaEthereumConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
 
 /**
- * @notice Demonstrates conditional logic: max(a, b) using encrypted comparison
+ * @notice Conditional logic without information leakage using FHE.select.
+ *         Demonstrates how to implement if-then-else logic on encrypted values
+ *         (computing max of two numbers). Using regular if/else would decrypt
+ *         and leak which branch was taken. FHE.select evaluates BOTH branches
+ *         and picks one based on the encrypted condition, preserving privacy.
  *
- * @dev Shows how to use FHE.select() for encrypted if-then-else logic.
+ * @dev ❌ Can't use if/else (leaks info!) ✅ Use FHE.select instead
+ *      ⚡ Gas: ~120k for select operation
  */
 contract FHEIfThenElse is ZamaEthereumConfig {
     euint8 private _a;
     euint8 private _b;
     euint8 private _max;
 
-    constructor() {}
-
     /// @notice Sets the first operand (encrypted)
     function setA(externalEuint8 inputA, bytes calldata inputProof) external {
         _a = FHE.fromExternal(inputA, inputProof);
@@ -31,14 +34,10 @@ contract FHEIfThenElse is ZamaEthereumConfig {
     /// @notice Compute max(a, b) without revealing which is larger
     /// @dev Uses FHE.select() - the encrypted "if-then-else"
     function computeMax() external {
-        // 🔍 Compare encrypted values - result is encrypted boolean!
-        // We don't know if a >= b, only the encrypted result
         ebool aIsGreaterOrEqual = FHE.ge(_a, _b);
 
-        // 🔀 FHE.select(condition, ifTrue, ifFalse)
-        // - BOTH branches are evaluated (no short-circuit)
-        // - Result is encrypted - no one knows which was selected
-        // - This is how you do "if-else" on encrypted values!
+        // 🔀 Why select? if/else would leak which branch was taken!
+        // select evaluates BOTH branches, picks one based on encrypted condition
         _max = FHE.select(aIsGreaterOrEqual, _a, _b);
 
         // Grant permissions for decryption

package/contracts/concepts/FHEAccessControl.sol

@@ -5,21 +5,20 @@ import {FHE, euint32, externalEuint32} from "@fhevm/solidity/lib/FHE.sol";
 import {ZamaEthereumConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
 
 /**
- * @notice Critical access control patterns in FHEVM: FHE.allow, FHE.allowThis, FHE.allowTransient. Includes common mistakes and correct implementations.
- *
- * @dev Key functions:
- *      FHE.allow(handle, address) - permanent permission
- *      FHE.allowThis(handle)      - permission for contract itself
- *      FHE.allowTransient(handle, address) - temporary, expires at tx end
+ * @notice Master class for FHE permission patterns and access control.
+ *         Explains the three permission types: allow() for permanent access,
+ *         allowThis() for contract operations, and allowTransient() for
+ *         temporary cross-contract calls. Includes correct and incorrect
+ *         usage examples to prevent common decryption failures.
+
+ * @dev allow() = permanent, allowThis() = contract permission,
+ *      allowTransient() = expires at TX end
+ *      Both allowThis + allow required for user decryption!
  */
 contract FHEAccessControl is ZamaEthereumConfig {
     euint32 private _secretValue;
     mapping(address => bool) public hasAccess;
 
-    constructor() {}
-
-    // ==================== CORRECT PATTERN ====================
-
     /// @notice ✅ CORRECT: Full access pattern for user decryption
     function storeWithFullAccess(
         externalEuint32 input,
@@ -27,13 +26,12 @@ contract FHEAccessControl is ZamaEthereumConfig {
     ) external {
         _secretValue = FHE.fromExternal(input, inputProof);
 
-        // ⚠️ CRITICAL: BOTH are required for user decryption!
-        FHE.allowThis(_secretValue); // Contract can operate on it
-        FHE.allow(_secretValue, msg.sender); // User can decrypt it
-
-        // ❓ Why allowThis is needed for user decryption?
-        // User decryption = re-encryption for user's key
-        // This requires contract's permission to "release" the value
+        // Why BOTH allowThis + allow?
+        // - allowThis: Contract authorizes "releasing" the encrypted value
+        // - allow(user): User can request decryption for their key
+        // Missing either = decryption fails!
+        FHE.allowThis(_secretValue);
+        FHE.allow(_secretValue, msg.sender);
 
         hasAccess[msg.sender] = true;
     }
@@ -42,7 +40,8 @@ contract FHEAccessControl is ZamaEthereumConfig {
     function grantAccess(address user) external {
         require(hasAccess[msg.sender], "Caller has no access to grant");
 
-        // ✅ Works because contract has allowThis permission
+        // Why this works: Contract already has allowThis from storeWithFullAccess
+        // We only need to grant allow(user) for the new user
         FHE.allow(_secretValue, user);
         hasAccess[user] = true;
     }
@@ -51,8 +50,6 @@ contract FHEAccessControl is ZamaEthereumConfig {
         return _secretValue;
     }
 
-    // ==================== WRONG PATTERNS (EDUCATIONAL) ====================
-
     /// @notice ❌ WRONG: Missing allowThis → user decryption FAILS
     function storeWithoutAllowThis(
         externalEuint32 input,
@@ -60,8 +57,9 @@ contract FHEAccessControl is ZamaEthereumConfig {
     ) external {
         _secretValue = FHE.fromExternal(input, inputProof);
 
-        // ❌ Missing: FHE.allowThis(_secretValue)
-        // User has permission, but decryption will FAIL!
+        // ❌ Common mistake: Only allow(user) without allowThis
+        // Result: User has permission but can't decrypt!
+        // Why? Decryption needs contract to authorize the release
         FHE.allow(_secretValue, msg.sender);
     }
 
@@ -72,21 +70,23 @@ contract FHEAccessControl is ZamaEthereumConfig {
     ) external {
         _secretValue = FHE.fromExternal(input, inputProof);
 
+        // ❌ Another mistake: Only allowThis without allow(user)
+        // Result: Contract can compute but no one can decrypt!
         FHE.allowThis(_secretValue);
-        // ❌ Missing: FHE.allow(_secretValue, msg.sender)
-        // Contract can operate, but no one can decrypt!
     }
 
-    // ==================== TRANSIENT ACCESS ====================
-
     /// @notice Temporary access - expires at end of transaction
-    /// @dev Use for: passing values between contracts in same tx
+    /// @dev ⚡ Gas: allowTransient ~50% cheaper than allow!
+    ///      Use for passing values between contracts in same TX
     function computeAndShareTransient(
         address recipient
     ) external returns (euint32) {
         euint32 computed = FHE.add(_secretValue, FHE.asEuint32(1));
 
-        // 💨 Transient = cheaper than permanent, auto-expires
+        // Why allowTransient instead of allow?
+        // - Cheaper: ~50% less gas than permanent allow
+        // - Auto-cleanup: Expires at TX end (no storage pollution)
+        // - Use case: Passing values between contracts in same transaction
         FHE.allowTransient(computed, recipient);
 
         return computed;

package/contracts/concepts/FHEAntiPatterns.sol

@@ -10,28 +10,19 @@ import {
 import {ZamaEthereumConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
 
 /**
- * @notice Common FHE mistakes and their correct alternatives. Covers: branching, permissions, require/revert, re-encryption, loops, noise, and deprecated APIs.
+ * @notice Comprehensive guide to FHE anti-patterns and their solutions.
+ *         Covers 9 critical mistakes: using if/else on encrypted values,
+ *         incorrect permission patterns, require() statements that leak info,
+ *         unbounded loops, noise accumulation, and deprecated APIs.
+ *         Each pattern shows both ❌ WRONG and ✅ CORRECT implementations.
  *
- * @dev This contract demonstrates 9 critical anti-patterns in FHE development:
- *      1. Branching on encrypted values (causes decryption!)
- *      2. Returning encrypted values without permissions
- *      3. Using require/revert with encrypted conditions
- *      4. Encrypted computation without permission grants
- *      5. Leaking information through gas/timing
- *      6. Unauthenticated re-encryption (security critical!)
- *      7. Encrypted loop iterations (gas/timing leak)
- *      8. Too many chained operations (noise accumulation)
- *      9. Using deprecated FHEVM APIs
- *
- *      Each anti-pattern shows both ❌ WRONG and ✅ CORRECT implementations.
+ * @dev Covers 9 critical anti-patterns with ❌ WRONG and ✅ CORRECT examples.
+ *      This is an educational contract - study each pattern before building production code!
  */
 contract FHEAntiPatterns is ZamaEthereumConfig {
     euint32 private _secretBalance;
     euint32 private _threshold;
 
-    // solhint-disable-next-line no-empty-blocks
-    constructor() {}
-
     /// @notice Initialize the contract with encrypted balance and threshold values
     /// @dev Both values are encrypted and permissions are granted to the caller
     function initialize(
@@ -48,9 +39,7 @@ contract FHEAntiPatterns is ZamaEthereumConfig {
         FHE.allow(_threshold, msg.sender);
     }
 
-    // ========================================================================
     // ANTI-PATTERN 1: Branching on encrypted values
-    // ========================================================================
 
     /**
      * ❌ WRONG: if/else on encrypted value causes decryption
@@ -90,9 +79,7 @@ contract FHEAntiPatterns is ZamaEthereumConfig {
         FHE.allow(_secretBalance, msg.sender);
     }
 
-    // ========================================================================
     // ANTI-PATTERN 2: View function returning encrypted without permissions
-    // ========================================================================
 
     /**
      * @notice ❌ WRONG: Returns encrypted value but caller can't decrypt
@@ -113,9 +100,7 @@ contract FHEAntiPatterns is ZamaEthereumConfig {
         return _secretBalance;
     }
 
-    // ========================================================================
     // ANTI-PATTERN 3: Using require/revert with encrypted conditions
-    // ========================================================================
 
     /**
      * ❌ WRONG: Cannot use require with encrypted values
@@ -141,9 +126,7 @@ contract FHEAntiPatterns is ZamaEthereumConfig {
         return hasEnough;
     }
 
-    // ========================================================================
     // ANTI-PATTERN 4: Encrypted computation without permission grants
-    // ========================================================================
 
     /**
      * @notice ❌ WRONG: Compute but forget to grant permissions
@@ -166,9 +149,7 @@ contract FHEAntiPatterns is ZamaEthereumConfig {
         FHE.allow(_secretBalance, msg.sender);
     }
 
-    // ========================================================================
     // ANTI-PATTERN 5: Leaking information through gas/timing
-    // ========================================================================
 
     /**
      * @notice ⚠️ CAUTION: Be aware of side-channel attacks
@@ -184,9 +165,7 @@ contract FHEAntiPatterns is ZamaEthereumConfig {
         return "Be aware of gas/timing side channels";
     }
 
-    // ========================================================================
     // ANTI-PATTERN 6: Unauthenticated Re-encryption (SECURITY CRITICAL)
-    // ========================================================================
 
     /**
      * @notice ❌ WRONG: Re-encrypt for any provided public key
@@ -221,9 +200,7 @@ contract FHEAntiPatterns is ZamaEthereumConfig {
             "Use fhevm.js userDecrypt which handles this automatically.";
     }
 
-    // ========================================================================
     // ANTI-PATTERN 7: Encrypted Loop Iterations (GAS/TIMING LEAK)
-    // ========================================================================
 
     /// ❌ WRONG: Using encrypted value as loop count
     /// @dev Loop count is visible through gas consumption and timing
@@ -264,9 +241,7 @@ contract FHEAntiPatterns is ZamaEthereumConfig {
         FHE.allow(accumulator, msg.sender);
     }
 
-    // ========================================================================
     // ANTI-PATTERN 8: Too Many Chained Operations (Noise Accumulation)
-    // ========================================================================
 
     /// @notice ⚠️ CAUTION: FHE operations accumulate "noise"
     /// @dev Each FHE operation adds noise to the ciphertext. After too many
@@ -285,9 +260,7 @@ contract FHEAntiPatterns is ZamaEthereumConfig {
             "If you need many operations, consider batching or restructuring logic.";
     }
 
-    // ========================================================================
     // ANTI-PATTERN 9: Using Deprecated FHEVM APIs
-    // ========================================================================
 
     /**
      * @notice Caution about deprecated FHEVM APIs
@@ -306,9 +279,7 @@ contract FHEAntiPatterns is ZamaEthereumConfig {
             "or userDecrypt pattern via fhevm.js for user decryption.";
     }
 
-    // ========================================================================
-    // SUMMARY: Key Rules (Always check before deploying!)
-    // ========================================================================
+    // SUMMARY: Key Rules
 
     /**
      * @notice Quick reference for FHE best practices