@inco/lightning 0.2.13 → 0.2.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inco/lightning",
-  "version": "0.2.13",
+  "version": "0.2.15",
   "repository": "https://github.com/Inco-fhevm/inco-monorepo",
   "files": [
     "src/",

package/src/Lib.alphanet.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/Lib.demonet.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);
+    }
 }

package/src/Lib.devnet.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/Lib.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);
+    }
 }