@inco/lightning 0.1.20

package/src/Lib.template.sol

@@ -0,0 +1,464 @@
+// Edit this file to automatically alter generated libraries
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import "./IncoLightning.sol";
+import {ebool, euint256, ETypes} from "./Types.sol";
+
+IncoLightning constant inco = IncoLightning(
+    0x000000000000000000000000000000000000baBe
+);
+address constant deployedBy = 0x000000000000000000000000000000000000baBe;
+
+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/Types.sol

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+// matches Zama's ids, cf contracts/inco-fhevm/dependencies/fhevm-0.0.1/contracts/contracts/TFHEExecutor.sol l97-124
+// https://github.com/zama-ai/fhevm/blob/be14f85eb5b17ee868bfa66c2c6c5db61d67c89f/lib/TFHEExecutor.sol#L86
+enum EOps {
+    Add, // 0
+    Sub, // 1
+    Mul, // 2
+    Div, // 3
+    Rem, // 4
+    BitAnd, // 5
+    BitOr, // 6
+    BitXor, // 7
+    Shl, // 8
+    Shr, // 9
+    Rotl, // 10
+    Rotr, // 11
+    Eq, // 12
+    Ne, // 13
+    Ge, // 14
+    Gt, // 15
+    Le, // 16
+    Lt, // 17
+    Min, // 18
+    Max, // 19
+    NegUNSUPPORTED, // 20
+    Not, // 21
+    NewInput, // 22
+    Cast, // 23
+    TrivialEncrypt, // 24
+    IfThenElse, // 25
+    Rand, // 26
+    RandBounded, // 27
+    DecryptionRequested // 28
+}
+
+type ebool is bytes32;
+type euint256 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
+enum ETypes {
+    Bool,
+    Uint4UNSUPPORTED,
+    Uint8UNSUPPORTED,
+    Uint16UNSUPPORTED,
+    Uint32UNSUPPORTED,
+    Uint64UNSUPPORTED,
+    Uint128UNSUPPORTED,
+    Uint160UNSUPPORTED,
+    Uint256,
+    Bytes64UNSUPPORTED,
+    Bytes128UNSUPPORTED,
+    Bytes256UNSUPPORTED
+}
+
+// check correctness of compute
+// revert acl
+
+/// 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;
+}
+
+error SenderNotAllowedForHandle(bytes32 handle, address sender);
+error SharerNotAllowedForHandle(bytes32 handle, address sharer);
+
+string constant EVM_HOST_CHAIN_PREFIX = "evm/";
+uint8 constant HANDLE_VERSION = 0;
+
+// IncoLightning only supports single-valued ciphertexts so this is always 0
+uint256 constant HANDLE_INDEX = 0;