create-fhevm-example 1.4.3 → 1.4.4

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

@@ -10,19 +10,11 @@ import {
 import {ZamaEthereumConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
 
 /**
- * @notice Demonstrates all FHE comparison operations on encrypted integers
+ * @notice Demonstrates all FHE comparison operations: eq, ne, gt, lt, ge, le, select
  *
- * @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 +22,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 +80,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

@@ -7,15 +7,14 @@ import {ZamaEthereumConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
 /**
  * @notice Demonstrates conditional logic: max(a, b) using encrypted comparison
  *
- * @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 +30,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,15 @@ 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 Critical access control patterns in FHEVM: FHE.allow, FHE.allowThis, FHE.allowTransient with common mistakes.
+
+ * @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 +21,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 +35,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 +45,6 @@ contract FHEAccessControl is ZamaEthereumConfig {
         return _secretValue;
     }
 
-    // ==================== WRONG PATTERNS (EDUCATIONAL) ====================
-
     /// @notice ❌ WRONG: Missing allowThis → user decryption FAILS
     function storeWithoutAllowThis(
         externalEuint32 input,
@@ -60,8 +52,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 +65,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,15 @@ 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 Common FHE mistakes and correct alternatives: branching, permissions, require, loops, noise, deprecated APIs.
  *
- * @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 +35,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 +75,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 +96,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 +122,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 +145,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 +161,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 +196,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 +237,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 +256,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 +275,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

package/contracts/concepts/FHEHandles.sol

@@ -5,24 +5,18 @@ import {FHE, euint32, externalEuint32} from "@fhevm/solidity/lib/FHE.sol";
 import {ZamaEthereumConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
 
 /**
- * @notice Understanding FHE handles: creation, computation, immutability, and symbolic execution in mock mode.
+ * @notice Understanding FHE handles: creation, computation, and immut ability.
  *
- * @dev Handle = uint256 pointer to encrypted data stored by FHE coprocessor.
- *      Types: euint8/16/32/64/128/256, ebool, eaddress, ebytes64/128/256
+ * @dev Handle = uint256 pointer to encrypted data. Operations create NEW handles (immutable).
+ *      ⚡ Gas: asEuint32 ~20k, fromExternal ~50k, add/sub ~100k
  */
 contract FHEHandles is ZamaEthereumConfig {
-    // 🔐 Storage handles - persist across transactions
-    // These are just uint256 pointers, actual ciphertext is off-chain
     euint32 private _storedValue;
     euint32 private _computedValue;
 
     event HandleCreated(string operation, uint256 gasUsed);
     event HandleStored(string description);
 
-    constructor() {}
-
-    // ==================== HANDLE CREATION ====================
-
     /// @notice Pattern 1: Create handle from user's encrypted input
     function createFromExternal(
         externalEuint32 input,
@@ -30,8 +24,7 @@ contract FHEHandles is ZamaEthereumConfig {
     ) external {
         uint256 gasBefore = gasleft();
 
-        // 📥 FHE.fromExternal: converts external handle to internal handle
-        // The proof is verified automatically
+        // fromExternal: validates proof and creates internal handle
         _storedValue = FHE.fromExternal(input, inputProof);
 
         emit HandleCreated("fromExternal", gasBefore - gasleft());
@@ -45,8 +38,7 @@ contract FHEHandles is ZamaEthereumConfig {
     function createFromPlaintext(uint32 plaintextValue) external {
         uint256 gasBefore = gasleft();
 
-        // 📥 FHE.asEuint32: encrypts a public constant
-        // Use for: thresholds, comparison values, zero-initialization
+        // asEuint32: encrypts a public constant (visible on-chain!)
         _storedValue = FHE.asEuint32(plaintextValue);
 
         emit HandleCreated("asEuint32", gasBefore - gasleft());
@@ -55,23 +47,18 @@ contract FHEHandles is ZamaEthereumConfig {
         FHE.allow(_storedValue, msg.sender);
     }
 
-    // ==================== HANDLE COMPUTATION ====================
-
-    /// @notice Key insight: FHE operations create NEW handles
-    /// @dev Original handles are IMMUTABLE - they never change
+    /// @notice ⚠️ Key insight: FHE operations create NEW handles (immutable!)
     function computeNewHandle() external {
         uint256 gasBefore = gasleft();
 
         euint32 constant10 = FHE.asEuint32(10);
 
-        // 🔄 FHE.add creates a BRAND NEW handle
-        // _storedValue handle is UNCHANGED
-        // _computedValue gets the NEW handle
+        // 🔄 Why NEW handle? FHE values are immutable - operations always create new ones
         _computedValue = FHE.add(_storedValue, constant10);
 
         emit HandleCreated("add (new handle)", gasBefore - gasleft());
 
-        // ⚠️ Must grant permissions for the NEW handle!
+        // Must grant permissions for NEW handle
         FHE.allowThis(_computedValue);
         FHE.allow(_computedValue, msg.sender);
 
@@ -94,18 +81,14 @@ contract FHEHandles is ZamaEthereumConfig {
         FHE.allow(_computedValue, msg.sender);
     }
 
-    // ==================== HANDLE IMMUTABILITY ====================
-
-    /// @notice Demonstrates: updating a variable creates NEW handle
+    /// @notice Demonstrates: updating variable creates NEW handle
     function demonstrateImmutability()
         external
         returns (euint32 original, euint32 updated)
     {
-        // 📌 Save reference to current handle
         euint32 originalHandle = _storedValue;
 
-        // 🔄 This creates NEW handle, assigns to _storedValue
-        // originalHandle still points to OLD value!
+        // This creates NEW handle! originalHandle still points to OLD value
         _storedValue = FHE.add(_storedValue, FHE.asEuint32(100));
 
         FHE.allowThis(_storedValue);
@@ -116,8 +99,6 @@ contract FHEHandles is ZamaEthereumConfig {
         return (originalHandle, _storedValue);
     }
 
-    // ==================== GETTERS ====================
-
     function getStoredValue() external view returns (euint32) {
         return _storedValue;
     }

package/contracts/concepts/FHEInputProof.sol

@@ -11,68 +11,46 @@ import {
 import {ZamaEthereumConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
 
 /**
- * @notice Explains input proof validation in FHEVM: what proofs are, why they are needed, and how to use them correctly with single and batched inputs.
+ * @notice Explains input proof validation in FHEVM: why proofs matter and how to batch inputs efficiently.
  *
- * @dev Why proofs? They ensure:
- *      1. Ciphertext is valid (not garbage data)
- *      2. Value is in valid range for the type
- *      3. Sender knows the plaintext (proof of knowledge)
+ * @dev Proofs ensure: valid ciphertext + correct range + proof of knowledge.
+ *      ⚡ Gas: Batching multiple values in ONE proof saves ~50k gas vs separate proofs!
  */
 contract FHEInputProof is ZamaEthereumConfig {
     euint32 private _singleValue;
     euint32 private _valueA;
     euint64 private _valueB;
 
-    constructor() {}
-
-    // ==================== SINGLE INPUT ====================
-
     /// @notice Receive single encrypted value with proof
     function setSingleValue(
         externalEuint32 encryptedInput,
         bytes calldata inputProof
     ) external {
-        // 📥 FHE.fromExternal validates proof automatically
-        // If proof is invalid → transaction reverts
-        // Proof ensures:
-        //   ✓ Valid euint32 ciphertext
-        //   ✓ Encrypted for THIS contract
-        //   ✓ Sender knows the plaintext
+        // 🔐 Why proof needed? Prevents: garbage data, wrong type, replay attacks
         _singleValue = FHE.fromExternal(encryptedInput, inputProof);
 
         FHE.allowThis(_singleValue);
         FHE.allow(_singleValue, msg.sender);
     }
 
-    // ==================== MULTIPLE INPUTS (BATCHED) ====================
-
-    /// @notice Receive multiple encrypted values with SINGLE proof
-    /// @dev Client-side batching is more gas-efficient!
-    ///
-    /// Client code:
-    ///   const input = fhevm.createEncryptedInput(contractAddr, userAddr);
-    ///   input.add32(valueA);  // → handles[0]
-    ///   input.add64(valueB);  // → handles[1]
-    ///   const enc = await input.encrypt();
-    ///   // enc.inputProof covers BOTH values!
+    /// @notice Receive multiple values with SINGLE proof (gas efficient!)
+    /// @dev Client batches: input.add32(a).add64(b).encrypt() → one proof for both!
     function setMultipleValues(
         externalEuint32 inputA,
         externalEuint64 inputB,
-        bytes calldata inputProof // ← Single proof covers both!
+        bytes calldata inputProof // Single proof covers both!
     ) external {
-        // Both validated by same proof
+        // 💡 Same proof validates both - saves ~50k gas!
         _valueA = FHE.fromExternal(inputA, inputProof);
         _valueB = FHE.fromExternal(inputB, inputProof);
 
-        // ⚠️ Each value needs its own permission grants
+        // Each value needs own permissions
         FHE.allowThis(_valueA);
         FHE.allowThis(_valueB);
         FHE.allow(_valueA, msg.sender);
         FHE.allow(_valueB, msg.sender);
     }
 
-    // ==================== COMPUTATION WITH NEW INPUT ====================
-
     /// @notice Add new encrypted input to existing stored value
     function addToValue(
         externalEuint32 addend,
@@ -88,8 +66,6 @@ contract FHEInputProof is ZamaEthereumConfig {
         FHE.allow(_singleValue, msg.sender);
     }
 
-    // ==================== GETTERS ====================
-
     function getSingleValue() external view returns (euint32) {
         return _singleValue;
     }