@inco/lightning 0.6.8 → 0.7.0

package/src/Lib.template.sol

@@ -5,9 +5,9 @@ pragma solidity ^0.8;
 import {IncoLightning} from "./IncoLightning.sol";
 import {ebool, euint256, eaddress, ETypes} from "./Types.sol";
 
-IncoLightning constant inco = IncoLightning(
-    0x000000000000000000000000000000000000baBe
-);
+// forge-lint: disable-next-line(screaming-snake-case-const)
+IncoLightning constant inco = IncoLightning(0x000000000000000000000000000000000000baBe);
+// forge-lint: disable-next-line(screaming-snake-case-const)
 address constant deployedBy = 0x000000000000000000000000000000000000baBe;
 
 function typeOf(bytes32 handle) pure returns (ETypes) {
@@ -15,6 +15,7 @@ function typeOf(bytes32 handle) pure returns (ETypes) {
 }
 
 library e {
+
     function sanitize(euint256 a) internal returns (euint256) {
         if (euint256.unwrap(a) == bytes32(0)) {
             return asEuint256(0);
@@ -109,30 +110,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) {
@@ -140,44 +126,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) {
@@ -185,44 +150,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) {
@@ -230,17 +174,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) {
@@ -423,23 +361,14 @@ library e {
     /// @dev costs the inco fee
     function randBounded(uint256 upperBound) internal returns (euint256) {
         return
-                            euint256.wrap(
-                inco.eRandBounded{value: inco.getFee()}(
-                    euint256.unwrap(asEuint256(upperBound)),
-                    ETypes.Uint256
-                )
+            euint256.wrap(
+                inco.eRandBounded{value: inco.getFee()}(euint256.unwrap(asEuint256(upperBound)), ETypes.Uint256)
             );
     }
 
     /// @dev costs the inco fee
     function randBounded(euint256 upperBound) internal returns (euint256) {
-        return
-                            euint256.wrap(
-                inco.eRandBounded{value: inco.getFee()}(
-                    euint256.unwrap(s(upperBound)),
-                    ETypes.Uint256
-                )
-            );
+        return euint256.wrap(inco.eRandBounded{value: inco.getFee()}(euint256.unwrap(s(upperBound)), ETypes.Uint256));
     }
 
     function asEuint256(uint256 a) internal returns (euint256) {
@@ -464,52 +393,37 @@ library e {
 
     /// @notice Creates a new encrypted uint256 assuming msg.sender is the user
     /// @dev costs the inco fee
-    function newEuint256(
-        bytes memory ciphertext
-    ) internal returns (euint256) {
+    function newEuint256(bytes memory ciphertext) internal returns (euint256) {
         return newEuint256(ciphertext, msg.sender);
     }
 
     /// @notice Creates a new encrypted uint256 for the given user.
     /// @dev costs the inco fee
-    function newEuint256(
-        bytes memory ciphertext,
-        address user
-    ) internal returns (euint256) {
+    function newEuint256(bytes memory ciphertext, address user) internal returns (euint256) {
         return inco.newEuint256{value: inco.getFee()}(ciphertext, user);
     }
 
     /// @notice Creates a new encrypted bool assuming msg.sender is the user
     /// @dev costs the inco fee
-    function newEbool(
-        bytes memory ciphertext
-    ) internal returns (ebool) {
+    function newEbool(bytes memory ciphertext) internal returns (ebool) {
         return newEbool(ciphertext, msg.sender);
     }
 
     /// @notice Creates a new encrypted bool for the given user.
     /// @dev costs the inco fee
-    function newEbool(
-        bytes memory ciphertext,
-        address user
-    ) internal returns (ebool) {
+    function newEbool(bytes memory ciphertext, address user) internal returns (ebool) {
         return inco.newEbool{value: inco.getFee()}(ciphertext, user);
     }
 
     /// @notice Creates a new encrypted address assuming msg.sender is the user
     /// @dev costs the inco fee
-    function newEaddress(
-        bytes memory ciphertext
-    ) internal returns (eaddress) {
+    function newEaddress(bytes memory ciphertext) internal returns (eaddress) {
         return newEaddress(ciphertext, msg.sender);
     }
 
     /// @notice Creates a new encrypted address for the given user.
     /// @dev costs the inco fee
-    function newEaddress(
-        bytes memory ciphertext,
-        address user
-    ) internal returns (eaddress) {
+    function newEaddress(bytes memory ciphertext, address user) internal returns (eaddress) {
         return inco.newEaddress{value: inco.getFee()}(ciphertext, user);
     }
 
@@ -553,48 +467,16 @@ 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, 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 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 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 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))));
     }
+
 }

package/src/Types.sol

@@ -3,110 +3,245 @@ 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
-        // These are pseudo-ops part of the decryption/callback system but we need to generate code for them so I am including them
-        DecryptionRequested, // 28
-        RequestFulfilled, // 29
-        EOP30, EOP31, EOP32, EOP33, EOP34, EOP35, EOP36, EOP37, EOP38, EOP39,
-        // Pseudo-operation for an ACL (persistent) allow
-        Allow, // 40
-        Reveal, // 41
-        EOP42, EOP43, EOP44, EOP45, EOP46, EOP47, EOP48, EOP49,
-        EOP50, EOP51, EOP52, EOP53, EOP54, EOP55, EOP56, EOP57, EOP58, EOP59,
-        EOP60, EOP61, EOP62, EOP63, EOP64, EOP65, EOP66, EOP67, EOP68, EOP69,
-        EOP70, EOP71, EOP72, EOP73, EOP74, EOP75, EOP76, EOP77, EOP78, EOP79,
-        EOP80, EOP81, EOP82, EOP83, EOP84, EOP85, EOP86, EOP87, EOP88, EOP89,
-        EOP90, EOP91, EOP92, EOP93, EOP94, EOP95, EOP96, EOP97, EOP98, EOP99,
-        NewEList, // 100
-        EListGet, // 101
-        EListGetOr, // 102
-        EListSet, // 103
-        EListInsert, // 104
-        EListAppend, // 105
-        EListConcat, // 106
-        EListSlice, // 107
-        EListRange, // 108
-        EListShuffle, // 109
-        EListReverse // 110
-    }
+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
+    // These are pseudo-ops part of the decryption/callback system but we need to generate code for them so I am including them
+    DecryptionRequested, // 28
+    RequestFulfilled, // 29
+    EOP30,
+    EOP31,
+    EOP32,
+    EOP33,
+    EOP34,
+    EOP35,
+    EOP36,
+    EOP37,
+    EOP38,
+    EOP39,
+    // Pseudo-operation for an ACL (persistent) allow
+    Allow, // 40
+    Reveal, // 41
+    EOP42,
+    EOP43,
+    EOP44,
+    EOP45,
+    EOP46,
+    EOP47,
+    EOP48,
+    EOP49,
+    EOP50,
+    EOP51,
+    EOP52,
+    EOP53,
+    EOP54,
+    EOP55,
+    EOP56,
+    EOP57,
+    EOP58,
+    EOP59,
+    EOP60,
+    EOP61,
+    EOP62,
+    EOP63,
+    EOP64,
+    EOP65,
+    EOP66,
+    EOP67,
+    EOP68,
+    EOP69,
+    EOP70,
+    EOP71,
+    EOP72,
+    EOP73,
+    EOP74,
+    EOP75,
+    EOP76,
+    EOP77,
+    EOP78,
+    EOP79,
+    EOP80,
+    EOP81,
+    EOP82,
+    EOP83,
+    EOP84,
+    EOP85,
+    EOP86,
+    EOP87,
+    EOP88,
+    EOP89,
+    EOP90,
+    EOP91,
+    EOP92,
+    EOP93,
+    EOP94,
+    EOP95,
+    EOP96,
+    EOP97,
+    EOP98,
+    EOP99,
+    NewEList, // 100
+    EListGet, // 101
+    EListGetOr, // 102
+    EListSet, // 103
+    EListInsert, // 104
+    EListAppend, // 105
+    EListConcat, // 106
+    EListSlice, // 107
+    EListRange, // 108
+    EListShuffle, // 109
+    EListReverse // 110
+}
+
+type ebool is bytes32;
+
+type euint256 is bytes32;
 
-    type ebool is bytes32;
-    type euint256 is bytes32;
-    type eaddress 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
-    enum ETypes {
-        Bool,
-        Uint4UNSUPPORTED,
-        Uint8UNSUPPORTED,
-        Uint16UNSUPPORTED,
-        Uint32UNSUPPORTED,
-        Uint64UNSUPPORTED,
-        Uint128UNSUPPORTED,
-        AddressOrUint160OrBytes20,
-        Uint256,
-        Bytes64UNSUPPORTED,
-        Bytes128UNSUPPORTED,
-        Bytes256UNSUPPORTED,
-        EmptyType12, // 12
-        EmptyType13, // 13
-        EmptyType14, // 14
-        EmptyType15, // 15
-        EmptyType16, // 16
-        EmptyType17, // 17
-        EmptyType18, // 18
-        EmptyType19, // 19
-        EmptyType20, EmptyType21, EmptyType22, EmptyType23, EmptyType24, EmptyType25, EmptyType26, EmptyType27, EmptyType28, EmptyType29,
-        EmptyType30, EmptyType31, EmptyType32, EmptyType33, EmptyType34, EmptyType35, EmptyType36, EmptyType37, EmptyType38, EmptyType39,
-        EmptyType40, EmptyType41, EmptyType42, EmptyType43, EmptyType44, EmptyType45, EmptyType46, EmptyType47, EmptyType48, EmptyType49,
-        EmptyType50, EmptyType51, EmptyType52, EmptyType53, EmptyType54, EmptyType55, EmptyType56, EmptyType57, EmptyType58, EmptyType59,
-        EmptyType60, EmptyType61, EmptyType62, EmptyType63, EmptyType64, EmptyType65, EmptyType66, EmptyType67, EmptyType68, EmptyType69,
-        EmptyType70, EmptyType71, EmptyType72, EmptyType73, EmptyType74, EmptyType75, EmptyType76, EmptyType77, EmptyType78, EmptyType79,
-        EmptyType80, EmptyType81, EmptyType82, EmptyType83, EmptyType84, EmptyType85, EmptyType86, EmptyType87, EmptyType88, EmptyType89,
-        EmptyType90, EmptyType91, EmptyType92, EmptyType93, EmptyType94, EmptyType95, EmptyType96, EmptyType97, EmptyType98, EmptyType99,
-        List // 100
-    }
+enum ETypes {
+    Bool,
+    Uint4UNSUPPORTED,
+    Uint8UNSUPPORTED,
+    Uint16UNSUPPORTED,
+    Uint32UNSUPPORTED,
+    Uint64UNSUPPORTED,
+    Uint128UNSUPPORTED,
+    AddressOrUint160OrBytes20,
+    Uint256,
+    Bytes64UNSUPPORTED,
+    Bytes128UNSUPPORTED,
+    Bytes256UNSUPPORTED,
+    EmptyType12, // 12
+    EmptyType13, // 13
+    EmptyType14, // 14
+    EmptyType15, // 15
+    EmptyType16, // 16
+    EmptyType17, // 17
+    EmptyType18, // 18
+    EmptyType19, // 19
+    EmptyType20,
+    EmptyType21,
+    EmptyType22,
+    EmptyType23,
+    EmptyType24,
+    EmptyType25,
+    EmptyType26,
+    EmptyType27,
+    EmptyType28,
+    EmptyType29,
+    EmptyType30,
+    EmptyType31,
+    EmptyType32,
+    EmptyType33,
+    EmptyType34,
+    EmptyType35,
+    EmptyType36,
+    EmptyType37,
+    EmptyType38,
+    EmptyType39,
+    EmptyType40,
+    EmptyType41,
+    EmptyType42,
+    EmptyType43,
+    EmptyType44,
+    EmptyType45,
+    EmptyType46,
+    EmptyType47,
+    EmptyType48,
+    EmptyType49,
+    EmptyType50,
+    EmptyType51,
+    EmptyType52,
+    EmptyType53,
+    EmptyType54,
+    EmptyType55,
+    EmptyType56,
+    EmptyType57,
+    EmptyType58,
+    EmptyType59,
+    EmptyType60,
+    EmptyType61,
+    EmptyType62,
+    EmptyType63,
+    EmptyType64,
+    EmptyType65,
+    EmptyType66,
+    EmptyType67,
+    EmptyType68,
+    EmptyType69,
+    EmptyType70,
+    EmptyType71,
+    EmptyType72,
+    EmptyType73,
+    EmptyType74,
+    EmptyType75,
+    EmptyType76,
+    EmptyType77,
+    EmptyType78,
+    EmptyType79,
+    EmptyType80,
+    EmptyType81,
+    EmptyType82,
+    EmptyType83,
+    EmptyType84,
+    EmptyType85,
+    EmptyType86,
+    EmptyType87,
+    EmptyType88,
+    EmptyType89,
+    EmptyType90,
+    EmptyType91,
+    EmptyType92,
+    EmptyType93,
+    EmptyType94,
+    EmptyType95,
+    EmptyType96,
+    EmptyType97,
+    EmptyType98,
+    EmptyType99,
+    List // 100
+}
 
 // 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 || t == ETypes.AddressOrUint160OrBytes20;
-    }
+function isTypeSupported(ETypes t) pure returns (bool) {
+    return t == ETypes.Uint256 || t == ETypes.Bool || t == ETypes.AddressOrUint160OrBytes20;
+}
 
-    error SenderNotAllowedForHandle(bytes32 handle, address sender);
-    error SharerNotAllowedForHandle(bytes32 handle, address sharer);
+error SenderNotAllowedForHandle(bytes32 handle, address sender);
+error SharerNotAllowedForHandle(bytes32 handle, address sharer);
 
 string constant EVM_HOST_CHAIN_PREFIX = "evm/";
 uint8 constant HANDLE_VERSION = 0;
@@ -114,9 +249,7 @@ uint8 constant HANDLE_VERSION = 0;
 // used to make sure a verifier contract is checking allowance access on purpose, using a bytes4 or bool return type
 // can lead to forging allowance vouchers using contract calls meant for an unrelated purpose, which lead to access
 // theft. Its a common pattern, notably used in EIP1271 (Signature Validation Procedure for Contracts)
-bytes32 constant ALLOWANCE_GRANTED_MAGIC_VALUE = keccak256(
-    "Inco Read Access on Provided Handle is Granted"
-);
+bytes32 constant ALLOWANCE_GRANTED_MAGIC_VALUE = keccak256("Inco Read Access on Provided Handle is Granted");
 
 // IncoLightning only supports single-valued ciphertexts so this is always 0
 // NOTE: this must be a uint8 to get hash agreement!
@@ -125,5 +258,6 @@ uint8 constant HANDLE_INDEX = 0;
 /// Util function to convert an ETypes to a bit mask
 /// @param t the type to convert to a bit mask
 function typeToBitMask(ETypes t) pure returns (bytes32) {
-    return bytes32(1 << uint256(t));
+    uint256 one = 1;
+    return bytes32(one << uint256(t));
 }

package/src/interfaces/IIncoLightning.sol

@@ -16,5 +16,7 @@ interface IIncoLightning is
     IHandleGeneration,
     IVersion
 {
+
     function initialize(address owner) external;
+
 }