@inco/lightning 0.2.13 → 0.2.15

package/src/libs/incoLightning_devnet_v0_340846814.sol

@@ -6,12 +6,16 @@
 pragma solidity ^0.8;
 
 import "../IncoLightning.sol";
-import { ebool, euint256, ETypes } from "../Types.sol";
+import { ebool, euint256, eaddress, ETypes, isTypeSupported } from "../Types.sol";
 
 IncoLightning constant inco = IncoLightning(0x3B22be60Ae699933959CA3cE147C96caa88Ccd3D);
 address constant deployedBy = 0x8202D2D747784Cb7D48868E44C42C4bf162a70BC;
 uint256 constant defaultDecryptionDelayLimit = 2 hours;
 
+function typeOf(bytes32 handle) pure returns (ETypes) {
+    return ETypes(uint8(uint256(handle) >> 8));
+}
+
 library e {
     function sanitize(euint256 a) internal returns (euint256) {
         if (euint256.unwrap(a) == bytes32(0)) {
@@ -27,6 +31,13 @@ library e {
         return a;
     }
 
+    function sanitize(eaddress a) internal returns (eaddress) {
+        if (eaddress.unwrap(a) == bytes32(0)) {
+            return asEaddress(address(0));
+        }
+        return a;
+    }
+
     function s(euint256 a) internal returns (euint256) {
         return sanitize(a);
     }
@@ -35,6 +46,10 @@ library e {
         return sanitize(a);
     }
 
+    function s(eaddress a) internal returns (eaddress) {
+        return sanitize(a);
+    }
+
     function add(euint256 a, euint256 b) internal returns (euint256) {
         return inco.eAdd(s(a), s(b));
     }
@@ -216,27 +231,51 @@ library e {
     }
 
     function eq(euint256 a, euint256 b) internal returns (ebool) {
-        return inco.eEq(s(a), s(b));
+        return inco.eEq(euint256.unwrap(s(a)), euint256.unwrap(s(b)));
     }
 
     function eq(euint256 a, uint256 b) internal returns (ebool) {
-        return inco.eEq(s(a), asEuint256(b));
+        return inco.eEq(euint256.unwrap(s(a)), euint256.unwrap(asEuint256(b)));
     }
 
     function eq(uint256 a, euint256 b) internal returns (ebool) {
-        return inco.eEq(asEuint256(a), s(b));
+        return inco.eEq(euint256.unwrap(asEuint256(a)), euint256.unwrap(s(b)));
+    }
+
+    function eq(eaddress a, address b) internal returns (ebool) {
+        return inco.eEq(eaddress.unwrap(s(a)), eaddress.unwrap(asEaddress(b)));
+    }
+
+    function eq(eaddress a, eaddress b) internal returns (ebool) {
+        return inco.eEq(eaddress.unwrap(s(a)), eaddress.unwrap(s(b)));
+    }
+
+    function eq(address a, eaddress b) internal returns (ebool) {
+        return inco.eEq(eaddress.unwrap(asEaddress(a)), eaddress.unwrap(s(b)));
     }
 
     function ne(euint256 a, euint256 b) internal returns (ebool) {
-        return inco.eNe(s(a), s(b));
+        return inco.eNe(euint256.unwrap(s(a)), euint256.unwrap(s(b)));
     }
 
     function ne(euint256 a, uint256 b) internal returns (ebool) {
-        return inco.eNe(s(a), asEuint256(b));
+        return inco.eNe(euint256.unwrap(s(a)), euint256.unwrap(asEuint256(b)));
     }
 
     function ne(uint256 a, euint256 b) internal returns (ebool) {
-        return inco.eNe(asEuint256(a), s(b));
+        return inco.eNe(euint256.unwrap(asEuint256(a)), euint256.unwrap(s(b)));
+    }
+
+    function ne(eaddress a, eaddress b) internal returns (ebool) {
+        return inco.eNe(eaddress.unwrap(s(a)), eaddress.unwrap(s(b)));
+    }
+
+    function ne(eaddress a, address b) internal returns (ebool) {
+        return inco.eNe(eaddress.unwrap(s(a)), eaddress.unwrap(asEaddress(b)));
+    }
+
+    function ne(address a, eaddress b) internal returns (ebool) {
+        return inco.eNe(eaddress.unwrap(asEaddress(a)), eaddress.unwrap(s(b)));
     }
 
     function ge(euint256 a, euint256 b) internal returns (ebool) {
@@ -335,6 +374,10 @@ library e {
         return inco.asEbool(a);
     }
 
+    function asEaddress(address a) internal returns (eaddress) {
+        return inco.asEaddress(a);
+    }
+
     function asEbool(euint256 a) internal returns (ebool) {
         return ebool.wrap(inco.eCast(euint256.unwrap(a), ETypes.Bool));
     }
@@ -351,6 +394,10 @@ library e {
         return inco.newEbool(ciphertext, user);
     }
 
+    function newEaddress(bytes memory ciphertext, address user) internal returns (eaddress) {
+        return inco.newEaddress(ciphertext, user);
+    }
+
     function allow(euint256 a, address to) internal {
         inco.allow(euint256.unwrap(a), to);
     }
@@ -359,6 +406,10 @@ library e {
         inco.allow(ebool.unwrap(a), to);
     }
 
+    function allow(eaddress a, address to) internal {
+        inco.allow(eaddress.unwrap(a), to);
+    }
+
     function allowThis(euint256 a) internal {
         allow(a, address(this));
     }
@@ -367,6 +418,10 @@ library e {
         allow(a, address(this));
     }
 
+    function allowThis(eaddress a) internal {
+        allow(a, address(this));
+    }
+
     function isAllowed(address user, euint256 a) internal view returns (bool) {
         return inco.isAllowed(euint256.unwrap(a), user);
     }
@@ -379,6 +434,10 @@ library e {
         return ebool.wrap(inco.eIfThenElse(s(control), ebool.unwrap(s(ifTrue)), ebool.unwrap(s(ifFalse))));
     }
 
+    function select(ebool control, eaddress ifTrue, eaddress ifFalse) internal returns (eaddress) {
+        return eaddress.wrap(inco.eIfThenElse(s(control), eaddress.unwrap(s(ifTrue)), eaddress.unwrap(s(ifFalse))));
+    }
+
     function requestDecryption(euint256 a, bytes4 callbackSelector, bytes memory callbackData) internal returns (uint256 requestId) {
         requestId = inco.requestDecryption(callbackSelector, block.timestamp + defaultDecryptionDelayLimit, euint256.unwrap(s(a)), callbackData);
     }
@@ -386,4 +445,8 @@ library e {
     function requestDecryption(ebool a, bytes4 callbackSelector, bytes memory callbackData) internal returns (uint256 requestId) {
         requestId = inco.requestDecryption(callbackSelector, block.timestamp + defaultDecryptionDelayLimit, ebool.unwrap(s(a)), callbackData);
     }
+
+    function requestDecryption(eaddress a, bytes4 callbackSelector, bytes memory callbackData) internal returns (uint256 requestId) {
+        requestId = inco.requestDecryption(callbackSelector, block.timestamp + defaultDecryptionDelayLimit, eaddress.unwrap(s(a)), callbackData);
+    }
 }

package/src/libs/incoLightning_testnet_v0_183408998.sol

@@ -6,12 +6,16 @@
 pragma solidity ^0.8;
 
 import "../IncoLightning.sol";
-import { ebool, euint256, ETypes } from "../Types.sol";
+import { ebool, euint256, eaddress, ETypes, isTypeSupported } from "../Types.sol";
 
 IncoLightning constant inco = IncoLightning(0x63D8135aF4D393B1dB43B649010c8D3EE19FC9fd);
 address constant deployedBy = 0x8202D2D747784Cb7D48868E44C42C4bf162a70BC;
 uint256 constant defaultDecryptionDelayLimit = 2 hours;
 
+function typeOf(bytes32 handle) pure returns (ETypes) {
+    return ETypes(uint8(uint256(handle) >> 8));
+}
+
 library e {
     function sanitize(euint256 a) internal returns (euint256) {
         if (euint256.unwrap(a) == bytes32(0)) {
@@ -27,6 +31,13 @@ library e {
         return a;
     }
 
+    function sanitize(eaddress a) internal returns (eaddress) {
+        if (eaddress.unwrap(a) == bytes32(0)) {
+            return asEaddress(address(0));
+        }
+        return a;
+    }
+
     function s(euint256 a) internal returns (euint256) {
         return sanitize(a);
     }
@@ -35,6 +46,10 @@ library e {
         return sanitize(a);
     }
 
+    function s(eaddress a) internal returns (eaddress) {
+        return sanitize(a);
+    }
+
     function add(euint256 a, euint256 b) internal returns (euint256) {
         return inco.eAdd(s(a), s(b));
     }
@@ -216,27 +231,51 @@ library e {
     }
 
     function eq(euint256 a, euint256 b) internal returns (ebool) {
-        return inco.eEq(s(a), s(b));
+        return inco.eEq(euint256.unwrap(s(a)), euint256.unwrap(s(b)));
     }
 
     function eq(euint256 a, uint256 b) internal returns (ebool) {
-        return inco.eEq(s(a), asEuint256(b));
+        return inco.eEq(euint256.unwrap(s(a)), euint256.unwrap(asEuint256(b)));
     }
 
     function eq(uint256 a, euint256 b) internal returns (ebool) {
-        return inco.eEq(asEuint256(a), s(b));
+        return inco.eEq(euint256.unwrap(asEuint256(a)), euint256.unwrap(s(b)));
+    }
+
+    function eq(eaddress a, address b) internal returns (ebool) {
+        return inco.eEq(eaddress.unwrap(s(a)), eaddress.unwrap(asEaddress(b)));
+    }
+
+    function eq(eaddress a, eaddress b) internal returns (ebool) {
+        return inco.eEq(eaddress.unwrap(s(a)), eaddress.unwrap(s(b)));
+    }
+
+    function eq(address a, eaddress b) internal returns (ebool) {
+        return inco.eEq(eaddress.unwrap(asEaddress(a)), eaddress.unwrap(s(b)));
     }
 
     function ne(euint256 a, euint256 b) internal returns (ebool) {
-        return inco.eNe(s(a), s(b));
+        return inco.eNe(euint256.unwrap(s(a)), euint256.unwrap(s(b)));
     }
 
     function ne(euint256 a, uint256 b) internal returns (ebool) {
-        return inco.eNe(s(a), asEuint256(b));
+        return inco.eNe(euint256.unwrap(s(a)), euint256.unwrap(asEuint256(b)));
     }
 
     function ne(uint256 a, euint256 b) internal returns (ebool) {
-        return inco.eNe(asEuint256(a), s(b));
+        return inco.eNe(euint256.unwrap(asEuint256(a)), euint256.unwrap(s(b)));
+    }
+
+    function ne(eaddress a, eaddress b) internal returns (ebool) {
+        return inco.eNe(eaddress.unwrap(s(a)), eaddress.unwrap(s(b)));
+    }
+
+    function ne(eaddress a, address b) internal returns (ebool) {
+        return inco.eNe(eaddress.unwrap(s(a)), eaddress.unwrap(asEaddress(b)));
+    }
+
+    function ne(address a, eaddress b) internal returns (ebool) {
+        return inco.eNe(eaddress.unwrap(asEaddress(a)), eaddress.unwrap(s(b)));
     }
 
     function ge(euint256 a, euint256 b) internal returns (ebool) {
@@ -335,6 +374,10 @@ library e {
         return inco.asEbool(a);
     }
 
+    function asEaddress(address a) internal returns (eaddress) {
+        return inco.asEaddress(a);
+    }
+
     function asEbool(euint256 a) internal returns (ebool) {
         return ebool.wrap(inco.eCast(euint256.unwrap(a), ETypes.Bool));
     }
@@ -351,6 +394,10 @@ library e {
         return inco.newEbool(ciphertext, user);
     }
 
+    function newEaddress(bytes memory ciphertext, address user) internal returns (eaddress) {
+        return inco.newEaddress(ciphertext, user);
+    }
+
     function allow(euint256 a, address to) internal {
         inco.allow(euint256.unwrap(a), to);
     }
@@ -359,6 +406,10 @@ library e {
         inco.allow(ebool.unwrap(a), to);
     }
 
+    function allow(eaddress a, address to) internal {
+        inco.allow(eaddress.unwrap(a), to);
+    }
+
     function allowThis(euint256 a) internal {
         allow(a, address(this));
     }
@@ -367,6 +418,10 @@ library e {
         allow(a, address(this));
     }
 
+    function allowThis(eaddress a) internal {
+        allow(a, address(this));
+    }
+
     function isAllowed(address user, euint256 a) internal view returns (bool) {
         return inco.isAllowed(euint256.unwrap(a), user);
     }
@@ -379,6 +434,10 @@ library e {
         return ebool.wrap(inco.eIfThenElse(s(control), ebool.unwrap(s(ifTrue)), ebool.unwrap(s(ifFalse))));
     }
 
+    function select(ebool control, eaddress ifTrue, eaddress ifFalse) internal returns (eaddress) {
+        return eaddress.wrap(inco.eIfThenElse(s(control), eaddress.unwrap(s(ifTrue)), eaddress.unwrap(s(ifFalse))));
+    }
+
     function requestDecryption(euint256 a, bytes4 callbackSelector, bytes memory callbackData) internal returns (uint256 requestId) {
         requestId = inco.requestDecryption(callbackSelector, block.timestamp + defaultDecryptionDelayLimit, euint256.unwrap(s(a)), callbackData);
     }
@@ -386,4 +445,8 @@ library e {
     function requestDecryption(ebool a, bytes4 callbackSelector, bytes memory callbackData) internal returns (uint256 requestId) {
         requestId = inco.requestDecryption(callbackSelector, block.timestamp + defaultDecryptionDelayLimit, ebool.unwrap(s(a)), callbackData);
     }
+
+    function requestDecryption(eaddress a, bytes4 callbackSelector, bytes memory callbackData) internal returns (uint256 requestId) {
+        requestId = inco.requestDecryption(callbackSelector, block.timestamp + defaultDecryptionDelayLimit, eaddress.unwrap(s(a)), callbackData);
+    }
 }

package/src/lightning-parts/EncryptedInput.gen.sol

@@ -4,10 +4,12 @@ pragma solidity ^0.8;
 import { BaseAccessControlList } from "./AccessControl/BaseAccessControlList.sol";
 import { EventCounter } from "./primitives/EventCounter.sol";
 import { HandleGeneration } from "./primitives/HandleGeneration.sol";
-import { euint256, ebool, ETypes, EVM_HOST_CHAIN_PREFIX, HANDLE_VERSION, HANDLE_INDEX } from "../Types.sol";
+import { euint256, ebool, eaddress, ETypes, EVM_HOST_CHAIN_PREFIX, HANDLE_VERSION, HANDLE_INDEX } from "../Types.sol";
 
 interface IEncryptedInputGen {
     function newEuint256(bytes memory ciphertext, address user) external returns (euint256 newValue);
 
     function newEbool(bytes memory ciphertext, address user) external returns (ebool newValue);
+
+    function newEaddress(bytes memory ciphertext, address user) external returns (eaddress newValue);
 }

package/src/lightning-parts/EncryptedInput.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.8;
 import {BaseAccessControlList} from "./AccessControl/BaseAccessControlList.sol";
 import {EventCounter} from "./primitives/EventCounter.sol";
 import {HandleGeneration} from "./primitives/HandleGeneration.sol";
-import {euint256, ebool, ETypes, EVM_HOST_CHAIN_PREFIX, HANDLE_VERSION, HANDLE_INDEX} from "../Types.sol";
+import {euint256, ebool, eaddress, ETypes, EVM_HOST_CHAIN_PREFIX, HANDLE_VERSION, HANDLE_INDEX} from "../Types.sol";
 import {IEncryptedInputGen} from "./EncryptedInput.gen.sol";
 
 abstract contract EncryptedInput is
@@ -38,6 +38,13 @@ abstract contract EncryptedInput is
         return ebool.wrap(newInput(ciphertext, user, ETypes.Bool));
     }
 
+    function newEaddress(
+        bytes memory ciphertext,
+        address user
+    ) external returns (eaddress newValue) {
+        return eaddress.wrap(newInput(ciphertext, user, ETypes.AddressOrUint160OrBytes20));
+    }
+
     function newInput(
         bytes memory ciphertext,
         address user,

package/src/lightning-parts/EncryptedOperations.gen.sol

@@ -31,9 +31,9 @@ interface IEncryptedOperationsGen {
 
     function eRotr(euint256 lhs, euint256 rhs) external returns (euint256 result);
 
-    function eEq(euint256 lhs, euint256 rhs) external returns (ebool result);
+    function eEq(bytes32 lhs, bytes32 rhs) external returns (ebool result);
 
-    function eNe(euint256 lhs, euint256 rhs) external returns (ebool result);
+    function eNe(bytes32 lhs, bytes32 rhs) external returns (ebool result);
 
     function eGe(euint256 lhs, euint256 rhs) external returns (ebool result);
 

package/src/lightning-parts/EncryptedOperations.sol

@@ -13,11 +13,20 @@ abstract contract EncryptedOperations is
     EventCounter,
     HandleGeneration
 {
-    error UnexpectedType(ETypes actual, ETypes expected);
+    error UnexpectedType(ETypes actual, bytes32 expectedTypes);
     error UnsupportedType(ETypes actual);
 
     uint256 private randCounter;
 
+    bytes32 constant EBOOL = bytes32(1 << uint256(ETypes.Bool));
+    bytes32 constant EUINT160 = bytes32(1 << uint256(ETypes.AddressOrUint160OrBytes20));
+    bytes32 constant EUINT256 = bytes32(1 << uint256(ETypes.Uint256));
+
+    bytes32 constant SUPPORTED_TYPES_MASK =
+        EBOOL |
+        EUINT160 |
+        EUINT256;
+
     event EAdd(
         euint256 indexed lhs,
         euint256 indexed rhs,
@@ -91,14 +100,14 @@ abstract contract EncryptedOperations is
         uint256 eventId
     );
     event EEq(
-        euint256 indexed lhs,
-        euint256 indexed rhs,
+        bytes32 indexed lhs,
+        bytes32 indexed rhs,
         ebool indexed result,
         uint256 eventId
     );
     event ENe(
-        euint256 indexed lhs,
-        euint256 indexed rhs,
+        bytes32 indexed lhs,
+        bytes32 indexed rhs,
         ebool indexed result,
         uint256 eventId
     );
@@ -166,26 +175,28 @@ abstract contract EncryptedOperations is
         uint256 eventId
     );
 
+    function typeToBitMask(ETypes t) internal pure returns (bytes32) {
+        return bytes32(1 << uint256(t));
+    }
+
     modifier checked(euint256 lhs, euint256 rhs) {
-        checkInput(euint256.unwrap(lhs), ETypes.Uint256);
-        checkInput(euint256.unwrap(rhs), ETypes.Uint256);
+        checkInput(euint256.unwrap(lhs), typeToBitMask(ETypes.Uint256));
+        checkInput(euint256.unwrap(rhs), typeToBitMask(ETypes.Uint256));
         _;
     }
 
     modifier checkedHandle(euint256 handle) {
-        checkInput(euint256.unwrap(handle), ETypes.Uint256);
+        checkInput(euint256.unwrap(handle), typeToBitMask(ETypes.Uint256));
         _;
     }
 
-    function checkInput(bytes32 input, ETypes requiredType) internal view {
+
+    function checkInput(bytes32 input, bytes32 requiredTypes) internal view {
         require(
             isAllowed(input, msg.sender),
             SenderNotAllowedForHandle(input, msg.sender)
         );
-        require(
-            typeOf(input) == requiredType,
-            UnexpectedType(typeOf(input), requiredType)
-        );
+        require(requiredTypes & typeToBitMask(typeOf(input)) != 0, UnexpectedType(typeOf(input), requiredTypes));
     }
 
     function createResultHandle(
@@ -310,9 +321,9 @@ abstract contract EncryptedOperations is
     ) external returns (bytes32 result) {
         ETypes lhsType = typeOf(lhs);
         ETypes rhsType = typeOf(rhs);
-        checkInput(lhs, lhsType);
-        checkInput(rhs, rhsType);
-        require(lhsType == rhsType, UnexpectedType(lhsType, rhsType));
+        checkInput(lhs, typeToBitMask(lhsType));
+        checkInput(rhs, typeToBitMask(rhsType));
+        require(lhsType == rhsType, UnexpectedType(lhsType, typeToBitMask(rhsType)));
         result = createResultHandle(EOps.BitAnd, lhsType, lhs, rhs);
         emit EBitAnd(lhs, rhs, result, getNewEventId());
     }
@@ -323,9 +334,9 @@ abstract contract EncryptedOperations is
     ) external returns (bytes32 result) {
         ETypes lhsType = typeOf(lhs);
         ETypes rhsType = typeOf(rhs);
-        checkInput(lhs, lhsType);
-        checkInput(rhs, rhsType);
-        require(lhsType == rhsType, UnexpectedType(lhsType, rhsType));
+        checkInput(lhs, typeToBitMask(lhsType));
+        checkInput(rhs, typeToBitMask(rhsType));
+        require(lhsType == rhsType, UnexpectedType(lhsType, typeToBitMask(rhsType)));
         result = createResultHandle(EOps.BitOr, lhsType, lhs, rhs);
         emit EBitOr(lhs, rhs, result, getNewEventId());
     }
@@ -336,9 +347,9 @@ abstract contract EncryptedOperations is
     ) external returns (bytes32 result) {
         ETypes lhsType = typeOf(lhs);
         ETypes rhsType = typeOf(rhs);
-        checkInput(lhs, lhsType);
-        checkInput(rhs, rhsType);
-        require(lhsType == rhsType, UnexpectedType(lhsType, rhsType));
+        checkInput(lhs, typeToBitMask(lhsType));
+        checkInput(rhs, typeToBitMask(rhsType));
+        require(lhsType == rhsType, UnexpectedType(lhsType, typeToBitMask(rhsType)));
         result = createResultHandle(EOps.BitXor, lhsType, lhs, rhs);
         emit EBitXor(lhs, rhs, result, getNewEventId());
     }
@@ -404,30 +415,36 @@ abstract contract EncryptedOperations is
     }
 
     function eEq(
-        euint256 lhs,
-        euint256 rhs
-    ) external checked(lhs, rhs) returns (ebool result) {
+        bytes32 lhs,
+        bytes32 rhs
+    ) external returns (ebool result) {
+        checkInput(lhs, SUPPORTED_TYPES_MASK);
+        checkInput(rhs, SUPPORTED_TYPES_MASK);
+
         result = ebool.wrap(
             createResultHandle(
                 EOps.Eq,
                 ETypes.Bool,
-                euint256.unwrap(lhs),
-                euint256.unwrap(rhs)
+                lhs,
+                rhs
             )
         );
         emit EEq(lhs, rhs, result, getNewEventId());
     }
 
     function eNe(
-        euint256 lhs,
-        euint256 rhs
-    ) external checked(lhs, rhs) returns (ebool result) {
+        bytes32 lhs,
+        bytes32 rhs
+    ) external returns (ebool result) {
+        checkInput(lhs, SUPPORTED_TYPES_MASK);
+        checkInput(rhs, SUPPORTED_TYPES_MASK);
+
         result = ebool.wrap(
             createResultHandle(
                 EOps.Ne,
                 ETypes.Bool,
-                euint256.unwrap(lhs),
-                euint256.unwrap(rhs)
+                lhs,
+                rhs
             )
         );
         emit ENe(lhs, rhs, result, getNewEventId());
@@ -524,7 +541,7 @@ abstract contract EncryptedOperations is
     }
 
     function eNot(ebool operand) external returns (ebool result) {
-        checkInput(ebool.unwrap(operand), ETypes.Bool);
+        checkInput(ebool.unwrap(operand), typeToBitMask(ETypes.Bool));
         result = ebool.wrap(
             createResultHandle(EOps.Not, ETypes.Bool, ebool.unwrap(operand))
         );
@@ -560,7 +577,7 @@ abstract contract EncryptedOperations is
         ETypes randType
     ) external returns (bytes32 result) {
         require(isTypeSupported(randType), UnsupportedType(randType));
-        checkInput(upperBound, ETypes.Uint256);
+        checkInput(upperBound, typeToBitMask(ETypes.Uint256));
 
         result = createResultHandle(
             EOps.RandBounded,
@@ -597,16 +614,16 @@ abstract contract EncryptedOperations is
         bytes32 ifTrue,
         bytes32 ifFalse
     ) internal view returns (ETypes ifTrueType) {
-        checkInput(ebool.unwrap(control), ETypes.Bool);
+        checkInput(ebool.unwrap(control), typeToBitMask(ETypes.Bool));
         ifTrueType = typeOf(ifTrue);
         require(
-            ifTrueType == ETypes.Uint256 || ifTrueType == ETypes.Bool,
+            ifTrueType == ETypes.Uint256 || ifTrueType == ETypes.Bool || ifTrueType == ETypes.AddressOrUint160OrBytes20,
             UnsupportedType(ifTrueType)
         );
         require(
             isAllowed(ifTrue, msg.sender),
             SenderNotAllowedForHandle(ifTrue, msg.sender)
         );
-        checkInput(ifFalse, ifTrueType);
+        checkInput(ifFalse, typeToBitMask(ifTrueType));
     }
 }

package/src/lightning-parts/TrivialEncryption.gen.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8;
 
 import { EventCounter } from "./primitives/EventCounter.sol";
-import { euint256, ebool, ETypes } from "../Types.sol";
+import { euint256, ebool, eaddress, ETypes } from "../Types.sol";
 import { BaseAccessControlList } from "./AccessControl/BaseAccessControlList.sol";
 import { HandleGeneration } from "./primitives/HandleGeneration.sol";
 
@@ -10,4 +10,6 @@ interface ITrivialEncryptionGen {
     function asEuint256(uint256 value) external returns (euint256 newEuint256);
 
     function asEbool(bool value) external returns (ebool newEbool);
+
+    function asEaddress(address value) external returns (eaddress newEaddress);
 }

package/src/lightning-parts/TrivialEncryption.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8;
 
 import {EventCounter} from "./primitives/EventCounter.sol";
-import {euint256, ebool, ETypes} from "../Types.sol";
+import {euint256, ebool, eaddress, ETypes} from "../Types.sol";
 import {BaseAccessControlList} from "./AccessControl/BaseAccessControlList.sol";
 import {HandleGeneration} from "./primitives/HandleGeneration.sol";
 import {ITrivialEncryptionGen} from "./TrivialEncryption.gen.sol";
@@ -29,6 +29,11 @@ abstract contract TrivialEncryption is
         return ebool.wrap(newTrivialEncrypt(castedValue, ETypes.Bool));
     }
 
+    function asEaddress(address value) external returns (eaddress newEaddress) {
+        bytes32 castedValue = bytes32(uint256(uint160(value)));
+        return eaddress.wrap(newTrivialEncrypt(castedValue, ETypes.AddressOrUint160OrBytes20));
+    }
+
     function newTrivialEncrypt(
         bytes32 plainTextBytes,
         ETypes handleType

package/src/lightning-parts/test/HandleMetadata.t.sol

@@ -7,7 +7,7 @@ import {TrivialEncryption} from "../TrivialEncryption.sol";
 import {EncryptedOperations} from "../EncryptedOperations.sol";
 import {EncryptedInput} from "../EncryptedInput.sol";
 import {EIP712} from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
-import {ETypes, ebool, euint256} from "../../Types.sol";
+import {ETypes, ebool, euint256, eaddress} from "../../Types.sol";
 
 contract TestHandleMetadata is
     EIP712,
@@ -29,6 +29,10 @@ contract TestHandleMetadata is
             typeOf(embedIndexTypeVersion(someHandle, ETypes.Uint256)) ==
                 ETypes.Uint256
         );
+        assert(
+            typeOf(embedIndexTypeVersion(someHandle, ETypes.AddressOrUint160OrBytes20)) ==
+                ETypes.AddressOrUint160OrBytes20
+        );
     }
 
     function testTrivialEncryptionHandleType() public {
@@ -36,6 +40,8 @@ contract TestHandleMetadata is
         assert(typeOf(boolHandle) == ETypes.Bool);
         bytes32 uintHandle = euint256.unwrap(this.asEuint256(42));
         assert(typeOf(uintHandle) == ETypes.Uint256);
+        bytes32 addressHandle = eaddress.unwrap(this.asEaddress(address(0xdeadbeef)));
+        assert(typeOf(addressHandle) == ETypes.AddressOrUint160OrBytes20);
     }
 
     function testOperationsHandleType() public {
@@ -44,6 +50,8 @@ contract TestHandleMetadata is
         ebool control = this.asEbool(true);
         ebool c = this.asEbool(false);
         ebool d = this.asEbool(true);
+        eaddress addr1 = this.asEaddress(address(0x0));
+        eaddress addr2 = this.asEaddress(address(0xdeadbeef));
 
         assert(typeOf(euint256.unwrap(this.eAdd(a, b))) == ETypes.Uint256);
         assert(typeOf(euint256.unwrap(this.eSub(a, b))) == ETypes.Uint256);
@@ -62,6 +70,7 @@ contract TestHandleMetadata is
                 this.eIfThenElse(control, ebool.unwrap(c), ebool.unwrap(d))
             ) == ETypes.Bool
         );
+        assert(typeOf(ebool.unwrap(this.eEq(eaddress.unwrap(addr1), eaddress.unwrap(addr2)))) == ETypes.Bool);
     }
 
     function testEIfThenElseChecksTypeCoherence() public {
@@ -72,7 +81,7 @@ contract TestHandleMetadata is
             abi.encodeWithSelector(
                 EncryptedOperations.UnexpectedType.selector,
                 ETypes.Bool,
-                ETypes.Uint256
+                typeToBitMask(ETypes.Uint256)
             )
         );
         this.eIfThenElse(control, euint256.unwrap(a), ebool.unwrap(b));
@@ -83,5 +92,7 @@ contract TestHandleMetadata is
         assert(typeOf(euint256.unwrap(a)) == ETypes.Uint256);
         ebool b = this.newEbool("ciphertext", address(this));
         assert(typeOf(ebool.unwrap(b)) == ETypes.Bool);
+        eaddress c = this.newEaddress("ciphertext", address(this));
+        assert(typeOf(eaddress.unwrap(c)) == ETypes.AddressOrUint160OrBytes20);
     }
 }