@inco/lightning 0.2.14 → 0.2.15

package/src/Lib.template.sol

@@ -3,7 +3,7 @@
 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(
     0x000000000000000000000000000000000000baBe
@@ -12,6 +12,10 @@ address constant deployedBy = 0x000000000000000000000000000000000000baBe;
 
 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));
     }
@@ -249,23 +264,43 @@ 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) {
@@ -364,6 +399,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));
     }
@@ -386,6 +425,13 @@ 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);
     }
@@ -394,6 +440,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));
     }
@@ -402,6 +452,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);
     }
@@ -436,6 +490,21 @@ library e {
             );
     }
 
+    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,
@@ -461,4 +530,17 @@ library e {
             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/Lib.testnet.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/Types.sol

@@ -39,6 +39,7 @@ pragma solidity ^0.8;
 
     type ebool is bytes32;
     type euint256 is bytes32;
+    type eaddress is bytes32;
 
 // matches Zama's ids, cf contracts/inco-fhevm/dependencies/fhevm-0.0.1/contracts/lib/TFHE.sol l24-35
 // https://github.com/zama-ai/fhevm/blob/61c0b3593414082b2da6e591252ed3721fe922d7/lib/TFHE.sol#L26
@@ -50,7 +51,7 @@ pragma solidity ^0.8;
         Uint32UNSUPPORTED,
         Uint64UNSUPPORTED,
         Uint128UNSUPPORTED,
-        Uint160UNSUPPORTED,
+        AddressOrUint160OrBytes20,
         Uint256,
         Bytes64UNSUPPORTED,
         Bytes128UNSUPPORTED,
@@ -63,7 +64,7 @@ pragma solidity ^0.8;
 /// Checks whether the given type is a valid numeric type or a boolean.
 /// @param t the type to check
     function isTypeSupported(ETypes t) pure returns (bool) {
-        return t == ETypes.Uint256 || t == ETypes.Bool;
+        return t == ETypes.Uint256 || t == ETypes.Bool || t == ETypes.AddressOrUint160OrBytes20;
     }
 
     error SenderNotAllowedForHandle(bytes32 handle, address sender);

package/src/libs/incoLightning_alphanet_v0_297966649.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(0x4651DfD7729aE5568092E7351fAaD872266d4CBd);
 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_demonet_v0_863421733.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(0xeBAFF6D578733E4603b99CBdbb221482F29a78E1);
 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);
+    }
 }