@inco/lightning 0.1.30 → 0.1.31

package/src/Lib.devnet.sol

@@ -0,0 +1,389 @@
+// AUTOGENERATED FILE. DO NOT EDIT.
+// This file was generated by the IncoLightning library generator.
+// The original template is located at Lib.template.sol
+
+/// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import "./IncoLightning.sol";
+import { ebool, euint256, ETypes } from "./Types.sol";
+
+IncoLightning constant inco = IncoLightning(0x3B22be60Ae699933959CA3cE147C96caa88Ccd3D);
+address constant deployedBy = 0x8202D2D747784Cb7D48868E44C42C4bf162a70BC;
+uint256 constant defaultDecryptionDelayLimit = 2 hours;
+
+library e {
+    function sanitize(euint256 a) internal returns (euint256) {
+        if (euint256.unwrap(a) == bytes32(0)) {
+            return asEuint256(0);
+        }
+        return a;
+    }
+
+    function sanitize(ebool a) internal returns (ebool) {
+        if (ebool.unwrap(a) == bytes32(0)) {
+            return asEbool(false);
+        }
+        return a;
+    }
+
+    function s(euint256 a) internal returns (euint256) {
+        return sanitize(a);
+    }
+
+    function s(ebool a) internal returns (ebool) {
+        return sanitize(a);
+    }
+
+    function add(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eAdd(s(a), s(b));
+    }
+
+    function add(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eAdd(s(a), asEuint256(b));
+    }
+
+    function add(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eAdd(asEuint256(a), s(b));
+    }
+
+    function sub(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eSub(s(a), s(b));
+    }
+
+    function sub(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eSub(s(a), asEuint256(b));
+    }
+
+    function sub(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eSub(asEuint256(a), s(b));
+    }
+
+    function mul(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eMul(s(a), s(b));
+    }
+
+    function mul(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eMul(s(a), asEuint256(b));
+    }
+
+    function mul(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eMul(asEuint256(a), s(b));
+    }
+
+    function div(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eDiv(s(a), s(b));
+    }
+
+    function div(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eDiv(s(a), asEuint256(b));
+    }
+
+    function div(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eDiv(asEuint256(a), s(b));
+    }
+
+    function rem(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eRem(s(a), s(b));
+    }
+
+    function rem(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eRem(s(a), asEuint256(b));
+    }
+
+    function rem(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eRem(asEuint256(a), s(b));
+    }
+
+    function and(euint256 a, euint256 b) internal returns (euint256) {
+        return euint256.wrap(inco.eBitAnd(euint256.unwrap(s(a)), euint256.unwrap(s(b))));
+    }
+
+    function and(euint256 a, uint256 b) internal returns (euint256) {
+        return euint256.wrap(inco.eBitAnd(euint256.unwrap(s(a)), euint256.unwrap(asEuint256(b))));
+    }
+
+    function and(uint256 a, euint256 b) internal returns (euint256) {
+        return euint256.wrap(inco.eBitAnd(euint256.unwrap(asEuint256(a)), euint256.unwrap(s(b))));
+    }
+
+    function and(ebool a, ebool b) internal returns (ebool) {
+        return ebool.wrap(inco.eBitAnd(ebool.unwrap(s(a)), ebool.unwrap(s(b))));
+    }
+
+    function and(ebool a, bool b) internal returns (ebool) {
+        return ebool.wrap(inco.eBitAnd(ebool.unwrap(s(a)), ebool.unwrap(asEbool(b))));
+    }
+
+    function and(bool a, ebool b) internal returns (ebool) {
+        return ebool.wrap(inco.eBitAnd(ebool.unwrap(asEbool(a)), ebool.unwrap(s(b))));
+    }
+
+    function or(euint256 a, euint256 b) internal returns (euint256) {
+        return euint256.wrap(inco.eBitOr(euint256.unwrap(s(a)), euint256.unwrap(s(b))));
+    }
+
+    function or(euint256 a, uint256 b) internal returns (euint256) {
+        return euint256.wrap(inco.eBitOr(euint256.unwrap(s(a)), euint256.unwrap(asEuint256(b))));
+    }
+
+    function or(uint256 a, euint256 b) internal returns (euint256) {
+        return euint256.wrap(inco.eBitOr(euint256.unwrap(asEuint256(a)), euint256.unwrap(s(b))));
+    }
+
+    function or(ebool a, ebool b) internal returns (ebool) {
+        return ebool.wrap(inco.eBitOr(ebool.unwrap(s(a)), ebool.unwrap(s(b))));
+    }
+
+    function or(ebool a, bool b) internal returns (ebool) {
+        return ebool.wrap(inco.eBitOr(ebool.unwrap(s(a)), ebool.unwrap(asEbool(b))));
+    }
+
+    function or(bool a, ebool b) internal returns (ebool) {
+        return ebool.wrap(inco.eBitOr(ebool.unwrap(asEbool(a)), ebool.unwrap(s(b))));
+    }
+
+    function xor(euint256 a, euint256 b) internal returns (euint256) {
+        return euint256.wrap(inco.eBitXor(euint256.unwrap(s(a)), euint256.unwrap(s(b))));
+    }
+
+    function xor(euint256 a, uint256 b) internal returns (euint256) {
+        return euint256.wrap(inco.eBitXor(euint256.unwrap(s(a)), euint256.unwrap(asEuint256(b))));
+    }
+
+    function xor(uint256 a, euint256 b) internal returns (euint256) {
+        return euint256.wrap(inco.eBitXor(euint256.unwrap(asEuint256(a)), euint256.unwrap(s(b))));
+    }
+
+    function xor(ebool a, ebool b) internal returns (ebool) {
+        return ebool.wrap(inco.eBitXor(ebool.unwrap(s(a)), ebool.unwrap(s(b))));
+    }
+
+    function xor(ebool a, bool b) internal returns (ebool) {
+        return ebool.wrap(inco.eBitXor(ebool.unwrap(s(a)), ebool.unwrap(asEbool(b))));
+    }
+
+    function xor(bool a, ebool b) internal returns (ebool) {
+        return ebool.wrap(inco.eBitXor(ebool.unwrap(asEbool(a)), ebool.unwrap(s(b))));
+    }
+
+    function shl(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eShl(s(a), s(b));
+    }
+
+    function shl(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eShl(s(a), asEuint256(b));
+    }
+
+    function shl(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eShl(asEuint256(a), s(b));
+    }
+
+    function shr(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eShr(s(a), s(b));
+    }
+
+    function shr(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eShr(s(a), asEuint256(b));
+    }
+
+    function shr(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eShr(asEuint256(a), s(b));
+    }
+
+    function rotl(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eRotl(s(a), s(b));
+    }
+
+    function rotl(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eRotl(s(a), asEuint256(b));
+    }
+
+    function rotl(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eRotl(asEuint256(a), s(b));
+    }
+
+    function rotr(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eRotr(s(a), s(b));
+    }
+
+    function rotr(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eRotr(s(a), asEuint256(b));
+    }
+
+    function rotr(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eRotr(asEuint256(a), s(b));
+    }
+
+    function eq(euint256 a, euint256 b) internal returns (ebool) {
+        return inco.eEq(s(a), s(b));
+    }
+
+    function eq(euint256 a, uint256 b) internal returns (ebool) {
+        return inco.eEq(s(a), asEuint256(b));
+    }
+
+    function eq(uint256 a, euint256 b) internal returns (ebool) {
+        return inco.eEq(asEuint256(a), s(b));
+    }
+
+    function ne(euint256 a, euint256 b) internal returns (ebool) {
+        return inco.eNe(s(a), s(b));
+    }
+
+    function ne(euint256 a, uint256 b) internal returns (ebool) {
+        return inco.eNe(s(a), asEuint256(b));
+    }
+
+    function ne(uint256 a, euint256 b) internal returns (ebool) {
+        return inco.eNe(asEuint256(a), s(b));
+    }
+
+    function ge(euint256 a, euint256 b) internal returns (ebool) {
+        return inco.eGe(s(a), s(b));
+    }
+
+    function ge(euint256 a, uint256 b) internal returns (ebool) {
+        return inco.eGe(s(a), asEuint256(b));
+    }
+
+    function ge(uint256 a, euint256 b) internal returns (ebool) {
+        return inco.eGe(asEuint256(a), s(b));
+    }
+
+    function gt(euint256 a, euint256 b) internal returns (ebool) {
+        return inco.eGt(s(a), s(b));
+    }
+
+    function gt(euint256 a, uint256 b) internal returns (ebool) {
+        return inco.eGt(s(a), asEuint256(b));
+    }
+
+    function gt(uint256 a, euint256 b) internal returns (ebool) {
+        return inco.eGt(asEuint256(a), s(b));
+    }
+
+    function le(euint256 a, euint256 b) internal returns (ebool) {
+        return inco.eLe(s(a), s(b));
+    }
+
+    function le(euint256 a, uint256 b) internal returns (ebool) {
+        return inco.eLe(s(a), asEuint256(b));
+    }
+
+    function le(uint256 a, euint256 b) internal returns (ebool) {
+        return inco.eLe(asEuint256(a), s(b));
+    }
+
+    function lt(euint256 a, euint256 b) internal returns (ebool) {
+        return inco.eLt(s(a), s(b));
+    }
+
+    function lt(euint256 a, uint256 b) internal returns (ebool) {
+        return inco.eLt(s(a), asEuint256(b));
+    }
+
+    function lt(uint256 a, euint256 b) internal returns (ebool) {
+        return inco.eLt(asEuint256(a), s(b));
+    }
+
+    function min(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eMin(s(a), s(b));
+    }
+
+    function min(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eMin(s(a), asEuint256(b));
+    }
+
+    function min(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eMin(asEuint256(a), s(b));
+    }
+
+    function max(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eMax(s(a), s(b));
+    }
+
+    function max(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eMax(s(a), asEuint256(b));
+    }
+
+    function max(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eMax(asEuint256(a), s(b));
+    }
+
+    function not(ebool a) internal returns (ebool) {
+        return inco.eNot(s(a));
+    }
+
+    function rand() internal returns (euint256) {
+        return euint256.wrap(inco.eRand(ETypes.Uint256));
+    }
+
+    function randBounded(uint256 upperBound) internal returns (euint256) {
+        return euint256.wrap(inco.eRandBounded(euint256.unwrap(asEuint256(upperBound)), ETypes.Uint256));
+    }
+
+    function randBounded(euint256 upperBound) internal returns (euint256) {
+        return euint256.wrap(inco.eRandBounded(euint256.unwrap(s(upperBound)), ETypes.Uint256));
+    }
+
+    function asEuint256(uint256 a) internal returns (euint256) {
+        return inco.asEuint256(a);
+    }
+
+    function asEbool(bool a) internal returns (ebool) {
+        return inco.asEbool(a);
+    }
+
+    function asEbool(euint256 a) internal returns (ebool) {
+        return ebool.wrap(inco.eCast(euint256.unwrap(a), ETypes.Bool));
+    }
+
+    function asEuint256(ebool a) internal returns (euint256) {
+        return euint256.wrap(inco.eCast(ebool.unwrap(a), ETypes.Uint256));
+    }
+
+    function newEuint256(bytes memory ciphertext, address user) internal returns (euint256) {
+        return inco.newEuint256(ciphertext, user);
+    }
+
+    function newEbool(bytes memory ciphertext, address user) internal returns (ebool) {
+        return inco.newEbool(ciphertext, user);
+    }
+
+    function allow(euint256 a, address to) internal {
+        inco.allow(euint256.unwrap(a), to);
+    }
+
+    function allow(ebool a, address to) internal {
+        inco.allow(ebool.unwrap(a), to);
+    }
+
+    function allowThis(euint256 a) internal {
+        allow(a, address(this));
+    }
+
+    function allowThis(ebool a) internal {
+        allow(a, address(this));
+    }
+
+    function isAllowed(address user, euint256 a) internal view returns (bool) {
+        return inco.isAllowed(euint256.unwrap(a), user);
+    }
+
+    function select(ebool control, euint256 ifTrue, euint256 ifFalse) internal returns (euint256) {
+        return euint256.wrap(inco.eIfThenElse(s(control), euint256.unwrap(s(ifTrue)), euint256.unwrap(s(ifFalse))));
+    }
+
+    function select(ebool control, ebool ifTrue, ebool ifFalse) internal returns (ebool) {
+        return ebool.wrap(inco.eIfThenElse(s(control), ebool.unwrap(s(ifTrue)), ebool.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);
+    }
+
+    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);
+    }
+}

package/src/Lib.sol

@@ -6,11 +6,9 @@
 pragma solidity ^0.8;
 
 import "./IncoLightning.sol";
-import {ebool, euint256, ETypes} from "./Types.sol";
+import { ebool, euint256, ETypes } from "./Types.sol";
 
-IncoLightning constant inco = IncoLightning(
-    0x63D8135aF4D393B1dB43B649010c8D3EE19FC9fd
-);
+IncoLightning constant inco = IncoLightning(0x63D8135aF4D393B1dB43B649010c8D3EE19FC9fd);
 address constant deployedBy = 0x8202D2D747784Cb7D48868E44C42C4bf162a70BC;
 uint256 constant defaultDecryptionDelayLimit = 2 hours;
 
@@ -98,30 +96,15 @@ library e {
     }
 
     function and(euint256 a, euint256 b) internal returns (euint256) {
-        return
-            euint256.wrap(
-                inco.eBitAnd(euint256.unwrap(s(a)), euint256.unwrap(s(b)))
-            );
+        return euint256.wrap(inco.eBitAnd(euint256.unwrap(s(a)), euint256.unwrap(s(b))));
     }
 
     function and(euint256 a, uint256 b) internal returns (euint256) {
-        return
-            euint256.wrap(
-                inco.eBitAnd(
-                    euint256.unwrap(s(a)),
-                    euint256.unwrap(asEuint256(b))
-                )
-            );
+        return euint256.wrap(inco.eBitAnd(euint256.unwrap(s(a)), euint256.unwrap(asEuint256(b))));
     }
 
     function and(uint256 a, euint256 b) internal returns (euint256) {
-        return
-            euint256.wrap(
-                inco.eBitAnd(
-                    euint256.unwrap(asEuint256(a)),
-                    euint256.unwrap(s(b))
-                )
-            );
+        return euint256.wrap(inco.eBitAnd(euint256.unwrap(asEuint256(a)), euint256.unwrap(s(b))));
     }
 
     function and(ebool a, ebool b) internal returns (ebool) {
@@ -129,44 +112,23 @@ library e {
     }
 
     function and(ebool a, bool b) internal returns (ebool) {
-        return
-            ebool.wrap(
-                inco.eBitAnd(ebool.unwrap(s(a)), ebool.unwrap(asEbool(b)))
-            );
+        return ebool.wrap(inco.eBitAnd(ebool.unwrap(s(a)), ebool.unwrap(asEbool(b))));
     }
 
     function and(bool a, ebool b) internal returns (ebool) {
-        return
-            ebool.wrap(
-                inco.eBitAnd(ebool.unwrap(asEbool(a)), ebool.unwrap(s(b)))
-            );
+        return ebool.wrap(inco.eBitAnd(ebool.unwrap(asEbool(a)), ebool.unwrap(s(b))));
     }
 
     function or(euint256 a, euint256 b) internal returns (euint256) {
-        return
-            euint256.wrap(
-                inco.eBitOr(euint256.unwrap(s(a)), euint256.unwrap(s(b)))
-            );
+        return euint256.wrap(inco.eBitOr(euint256.unwrap(s(a)), euint256.unwrap(s(b))));
     }
 
     function or(euint256 a, uint256 b) internal returns (euint256) {
-        return
-            euint256.wrap(
-                inco.eBitOr(
-                    euint256.unwrap(s(a)),
-                    euint256.unwrap(asEuint256(b))
-                )
-            );
+        return euint256.wrap(inco.eBitOr(euint256.unwrap(s(a)), euint256.unwrap(asEuint256(b))));
     }
 
     function or(uint256 a, euint256 b) internal returns (euint256) {
-        return
-            euint256.wrap(
-                inco.eBitOr(
-                    euint256.unwrap(asEuint256(a)),
-                    euint256.unwrap(s(b))
-                )
-            );
+        return euint256.wrap(inco.eBitOr(euint256.unwrap(asEuint256(a)), euint256.unwrap(s(b))));
     }
 
     function or(ebool a, ebool b) internal returns (ebool) {
@@ -174,44 +136,23 @@ library e {
     }
 
     function or(ebool a, bool b) internal returns (ebool) {
-        return
-            ebool.wrap(
-                inco.eBitOr(ebool.unwrap(s(a)), ebool.unwrap(asEbool(b)))
-            );
+        return ebool.wrap(inco.eBitOr(ebool.unwrap(s(a)), ebool.unwrap(asEbool(b))));
     }
 
     function or(bool a, ebool b) internal returns (ebool) {
-        return
-            ebool.wrap(
-                inco.eBitOr(ebool.unwrap(asEbool(a)), ebool.unwrap(s(b)))
-            );
+        return ebool.wrap(inco.eBitOr(ebool.unwrap(asEbool(a)), ebool.unwrap(s(b))));
     }
 
     function xor(euint256 a, euint256 b) internal returns (euint256) {
-        return
-            euint256.wrap(
-                inco.eBitXor(euint256.unwrap(s(a)), euint256.unwrap(s(b)))
-            );
+        return euint256.wrap(inco.eBitXor(euint256.unwrap(s(a)), euint256.unwrap(s(b))));
     }
 
     function xor(euint256 a, uint256 b) internal returns (euint256) {
-        return
-            euint256.wrap(
-                inco.eBitXor(
-                    euint256.unwrap(s(a)),
-                    euint256.unwrap(asEuint256(b))
-                )
-            );
+        return euint256.wrap(inco.eBitXor(euint256.unwrap(s(a)), euint256.unwrap(asEuint256(b))));
     }
 
     function xor(uint256 a, euint256 b) internal returns (euint256) {
-        return
-            euint256.wrap(
-                inco.eBitXor(
-                    euint256.unwrap(asEuint256(a)),
-                    euint256.unwrap(s(b))
-                )
-            );
+        return euint256.wrap(inco.eBitXor(euint256.unwrap(asEuint256(a)), euint256.unwrap(s(b))));
     }
 
     function xor(ebool a, ebool b) internal returns (ebool) {
@@ -219,17 +160,11 @@ library e {
     }
 
     function xor(ebool a, bool b) internal returns (ebool) {
-        return
-            ebool.wrap(
-                inco.eBitXor(ebool.unwrap(s(a)), ebool.unwrap(asEbool(b)))
-            );
+        return ebool.wrap(inco.eBitXor(ebool.unwrap(s(a)), ebool.unwrap(asEbool(b))));
     }
 
     function xor(bool a, ebool b) internal returns (ebool) {
-        return
-            ebool.wrap(
-                inco.eBitXor(ebool.unwrap(asEbool(a)), ebool.unwrap(s(b)))
-            );
+        return ebool.wrap(inco.eBitXor(ebool.unwrap(asEbool(a)), ebool.unwrap(s(b))));
     }
 
     function shl(euint256 a, euint256 b) internal returns (euint256) {
@@ -385,23 +320,11 @@ library e {
     }
 
     function randBounded(uint256 upperBound) internal returns (euint256) {
-        return
-            euint256.wrap(
-                inco.eRandBounded(
-                    euint256.unwrap(asEuint256(upperBound)),
-                    ETypes.Uint256
-                )
-            );
+        return euint256.wrap(inco.eRandBounded(euint256.unwrap(asEuint256(upperBound)), ETypes.Uint256));
     }
 
     function randBounded(euint256 upperBound) internal returns (euint256) {
-        return
-            euint256.wrap(
-                inco.eRandBounded(
-                    euint256.unwrap(s(upperBound)),
-                    ETypes.Uint256
-                )
-            );
+        return euint256.wrap(inco.eRandBounded(euint256.unwrap(s(upperBound)), ETypes.Uint256));
     }
 
     function asEuint256(uint256 a) internal returns (euint256) {
@@ -420,17 +343,11 @@ library e {
         return euint256.wrap(inco.eCast(ebool.unwrap(a), ETypes.Uint256));
     }
 
-    function newEuint256(
-        bytes memory ciphertext,
-        address user
-    ) internal returns (euint256) {
+    function newEuint256(bytes memory ciphertext, address user) internal returns (euint256) {
         return inco.newEuint256(ciphertext, user);
     }
 
-    function newEbool(
-        bytes memory ciphertext,
-        address user
-    ) internal returns (ebool) {
+    function newEbool(bytes memory ciphertext, address user) internal returns (ebool) {
         return inco.newEbool(ciphertext, user);
     }
 
@@ -454,59 +371,19 @@ library e {
         return inco.isAllowed(euint256.unwrap(a), user);
     }
 
-    function select(
-        ebool control,
-        euint256 ifTrue,
-        euint256 ifFalse
-    ) internal returns (euint256) {
-        return
-            euint256.wrap(
-                inco.eIfThenElse(
-                    s(control),
-                    euint256.unwrap(s(ifTrue)),
-                    euint256.unwrap(s(ifFalse))
-                )
-            );
-    }
-
-    function select(
-        ebool control,
-        ebool ifTrue,
-        ebool ifFalse
-    ) internal returns (ebool) {
-        return
-            ebool.wrap(
-                inco.eIfThenElse(
-                    s(control),
-                    ebool.unwrap(s(ifTrue)),
-                    ebool.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
-        );
-    }
-
-    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 select(ebool control, euint256 ifTrue, euint256 ifFalse) internal returns (euint256) {
+        return euint256.wrap(inco.eIfThenElse(s(control), euint256.unwrap(s(ifTrue)), euint256.unwrap(s(ifFalse))));
+    }
+
+    function select(ebool control, ebool ifTrue, ebool ifFalse) internal returns (ebool) {
+        return ebool.wrap(inco.eIfThenElse(s(control), ebool.unwrap(s(ifTrue)), ebool.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);
+    }
+
+    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);
+    }
+}