@inco/lightning 0.8.0-devnet-3 → 0.8.0-devnet-4

package/package.json

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

package/src/lightning-parts/EncryptedInput.sol

@@ -17,52 +17,61 @@ error ExternalHandleDoesNotMatchComputedHandle(
     uint256 chainId,
     address aclAddress,
     address userAddress,
-    address contractAddress
+    address contractAddress,
+    int32 version
 );
 
 abstract contract EncryptedInput is IEncryptedInput, BaseAccessControlList, HandleGeneration, Fee {
 
     event NewInput(
-        bytes32 indexed result, address indexed contractAddress, address indexed user, bytes ciphertext, uint256 eventId
+        bytes32 indexed result,
+        address indexed contractAddress,
+        address indexed user,
+        int32 version,
+        bytes ciphertext,
+        uint256 eventId
     );
 
-    function newEuint256(bytes memory input, address user) external payable returns (euint256 newValue) {
+    function newEuint256(bytes calldata input, address user) external payable returns (euint256 newValue) {
         return euint256.wrap(newInput(input, user, ETypes.Uint256));
     }
 
-    function newEbool(bytes memory input, address user) external payable returns (ebool newValue) {
+    function newEbool(bytes calldata input, address user) external payable returns (ebool newValue) {
         return ebool.wrap(newInput(input, user, ETypes.Bool));
     }
 
-    function newEaddress(bytes memory input, address user) external payable returns (eaddress newValue) {
+    function newEaddress(bytes calldata input, address user) external payable returns (eaddress newValue) {
         return eaddress.wrap(newInput(input, user, ETypes.AddressOrUint160OrBytes20));
     }
 
-    function newInput(bytes memory ciphertext, address user, ETypes inputType)
+    function newInput(bytes calldata input, address user, ETypes inputType)
         internal
         paying
         returns (bytes32 newHandle)
     {
-        newHandle = _newInput(ciphertext, user, inputType);
+        newHandle = _newInput(input, user, inputType);
     }
 
-    function newInputNotPaying(bytes memory ciphertext, address user, ETypes inputType)
+    function newInputNotPaying(bytes calldata input, address user, ETypes inputType)
         internal
         returns (bytes32 newHandle)
     {
-        newHandle = _newInput(ciphertext, user, inputType);
+        newHandle = _newInput(input, user, inputType);
     }
 
     /// @notice Creates a new input with a prepended handle as a checksum.
     /// @param input The input that contains the handle prepended to the ciphertext.
     /// @param user The user address associated with the input.
-    function _newInput(bytes memory input, address user, ETypes inputType) private returns (bytes32 handle) {
+    function _newInput(bytes calldata input, address user, ETypes inputType) private returns (bytes32 handle) {
         // Since there is no sensible way to handle abi.decode errors (https://github.com/argotorg/solidity/issues/10381)
         // at least fail early on a conservative minimum length
-        require(input.length >= 64, "Input too short, should be at least 64 bytes");
+        require(input.length >= 68, "Input too short, should be at least 68 bytes");
+        // Parse the version from the first 4 bytes.
+        bytes4 prefix = bytes4(input[:4]);
+        int32 version = int32(uint32(prefix));
         // Remove external handle prepended to input as a checksum
-        (bytes32 externalHandle, bytes memory ciphertext) = abi.decode(input, (bytes32, bytes));
-        handle = getInputHandle(ciphertext, user, msg.sender, inputType);
+        (bytes32 externalHandle, bytes memory ciphertext) = abi.decode(input[4:], (bytes32, bytes));
+        handle = getInputHandle(ciphertext, user, msg.sender, version, inputType);
         require(
             handle == externalHandle,
             ExternalHandleDoesNotMatchComputedHandle({
@@ -71,14 +80,22 @@ abstract contract EncryptedInput is IEncryptedInput, BaseAccessControlList, Hand
                 chainId: block.chainid,
                 aclAddress: address(this),
                 userAddress: user,
-                contractAddress: msg.sender
+                contractAddress: msg.sender,
+                version: version
             })
         );
         // We assume that providing the same handle (which via HADU implies same plaintext, same context, and same
         // instance of encryption)
         require(!isAllowed(handle, user), HandleAlreadyExists(handle));
         uint256 id = getNextEventId();
-        emit NewInput({result: handle, contractAddress: msg.sender, user: user, ciphertext: ciphertext, eventId: id});
+        emit NewInput({
+            result: handle,
+            contractAddress: msg.sender,
+            user: user,
+            version: version,
+            ciphertext: ciphertext,
+            eventId: id
+        });
         setDigest(abi.encodePacked(handle, id));
         // We allow to user since this is harmless and it is convenient to use the allow mapping to track inputs.
         // NOTE: the allow must come after emitting the new input event, since allow emits its own event.

package/src/lightning-parts/interfaces/IEncryptedInput.sol

@@ -5,8 +5,8 @@ import {euint256, ebool, eaddress} from "../../Types.sol";
 
 interface IEncryptedInput {
 
-    function newEuint256(bytes memory ciphertext, address user) external payable returns (euint256 newValue);
-    function newEbool(bytes memory ciphertext, address user) external payable returns (ebool newValue);
-    function newEaddress(bytes memory ciphertext, address user) external payable returns (eaddress newValue);
+    function newEuint256(bytes calldata ciphertext, address user) external payable returns (euint256 newValue);
+    function newEbool(bytes calldata ciphertext, address user) external payable returns (ebool newValue);
+    function newEaddress(bytes calldata ciphertext, address user) external payable returns (eaddress newValue);
 
 }

package/src/lightning-parts/primitives/HandleGeneration.sol

@@ -21,12 +21,14 @@ contract HandleGeneration is IHandleGeneration, HandleMetadata {
         generatedHandle = embedTypeVersion(generatedHandle, handleType);
     }
 
-    function getInputHandle(bytes memory ciphertext, address user, address contractAddress, ETypes inputType)
-        internal
-        view
-        returns (bytes32 generatedHandle)
-    {
-        return getInputHandle(ciphertext, address(this), user, contractAddress, inputType);
+    function getInputHandle(
+        bytes memory ciphertext,
+        address user,
+        address contractAddress,
+        int32 version,
+        ETypes inputType
+    ) internal view returns (bytes32 generatedHandle) {
+        return getInputHandle(ciphertext, address(this), user, contractAddress, version, inputType);
     }
 
     function getInputHandle(
@@ -34,6 +36,7 @@ contract HandleGeneration is IHandleGeneration, HandleMetadata {
         address executorAddress,
         address user,
         address contractAddress,
+        int32 version,
         ETypes inputType
     ) internal view returns (bytes32 generatedHandle) {
         // Here we ensure that our hashing scheme is binary-compatible between IncoLightning and IncoFhevm, this helps
@@ -49,7 +52,8 @@ contract HandleGeneration is IHandleGeneration, HandleMetadata {
                     block.chainid, // todo cache this
                     executorAddress,
                     user,
-                    contractAddress
+                    contractAddress,
+                    version
                 )
             ),
             inputType

package/src/lightning-parts/test/HandleMetadata.t.sol

@@ -105,8 +105,16 @@ contract TestHandleMetadata is
     {
         // We need a single word here to get correct encoding
         bytes memory ciphertext = abi.encode(word);
-        bytes32 handle = getInputHandle(ciphertext, address(this), user, contractAddress, inputType);
-        input = abi.encode(handle, ciphertext);
+        bytes32 handle = getInputHandle(
+            ciphertext,
+            address(this),
+            user,
+            contractAddress,
+            0,
+            /* unspecified */
+            inputType
+        );
+        input = abi.encodePacked(int32(0), abi.encode(handle, ciphertext));
     }
 
     // ============ Tests for HandleGeneration functions ============
@@ -143,11 +151,8 @@ contract TestHandleMetadata is
     // ============ Tests for EncryptedInput internal functions ============
 
     /// @notice Expose the internal newInputNotPaying for testing
-    function exposedNewInputNotPaying(bytes memory ciphertext, address user, ETypes inputType)
-        public
-        returns (bytes32)
-    {
-        return newInputNotPaying(ciphertext, user, inputType);
+    function exposedNewInputNotPaying(bytes calldata input, address user, ETypes inputType) public returns (bytes32) {
+        return newInputNotPaying(input, user, inputType);
     }
 
     function testNewInputNotPaying() public {
@@ -167,9 +172,10 @@ contract TestHandleMetadata is
         returns (bytes memory input)
     {
         bytes memory ciphertext = abi.encode(word);
+        int32 version = 0; // unspecified
         // For external calls via this., msg.sender is address(this)
-        bytes32 handle = getInputHandle(ciphertext, address(this), user, address(this), inputType);
-        input = abi.encode(handle, ciphertext);
+        bytes32 handle = getInputHandle(ciphertext, address(this), user, address(this), version, inputType);
+        input = abi.encodePacked(version, abi.encode(handle, ciphertext));
     }
 
     // ============ Tests for EncryptedInput error branches ============
@@ -178,7 +184,7 @@ contract TestHandleMetadata is
         address self = address(this);
         // Input less than 64 bytes should revert
         bytes memory shortInput = hex"deadbeef";
-        vm.expectRevert("Input too short, should be at least 64 bytes");
+        vm.expectRevert("Input too short, should be at least 68 bytes");
         this.exposedNewInputNotPaying(shortInput, self, ETypes.Uint256);
     }
 
@@ -188,10 +194,11 @@ contract TestHandleMetadata is
         bytes memory ciphertext = abi.encode(ciphertextData);
         // Create input with wrong handle (just a random bytes32)
         bytes32 wrongHandle = bytes32(uint256(12345));
-        bytes memory badInput = abi.encode(wrongHandle, ciphertext);
+        int32 version = 0; // unspecified
+        bytes memory badInput = abi.encodePacked(version, abi.encode(wrongHandle, ciphertext));
 
         // Compute the expected handle for the error message
-        bytes32 expectedHandle = getInputHandle(ciphertext, address(this), self, address(this), ETypes.Uint256);
+        bytes32 expectedHandle = getInputHandle(ciphertext, address(this), self, address(this), version, ETypes.Uint256);
 
         vm.expectRevert(
             abi.encodeWithSelector(
@@ -201,7 +208,8 @@ contract TestHandleMetadata is
                 block.chainid,
                 address(this),
                 self,
-                address(this)
+                address(this),
+                version
             )
         );
         this.exposedNewInputNotPaying(badInput, self, ETypes.Uint256);

package/src/test/FakeIncoInfra/FakeIncoInfraBase.sol

@@ -19,8 +19,16 @@ contract FakeIncoInfraBase is TestUtils, KVStore, HandleGeneration {
     {
         // We need a single word here to get correct encoding
         bytes memory ciphertext = abi.encode(word);
-        bytes32 handle = getInputHandle(ciphertext, address(inco), user, contractAddress, inputType);
-        input = abi.encode(handle, ciphertext);
+        bytes32 handle = getInputHandle(
+            ciphertext,
+            address(inco),
+            user,
+            contractAddress,
+            0,
+            /* unspecified */
+            inputType
+        );
+        input = abi.encodePacked(int32(0), abi.encode(handle, ciphertext));
     }
 
     function fakePrepareEuint256Ciphertext(uint256 value, address userAddress, address contractAddress)

package/src/test/FakeIncoInfra/MockOpHandler.sol

@@ -63,7 +63,7 @@ contract MockOpHandler is FakeIncoInfraBase, FakeComputeServer {
         } else if (op == EOps.NewInput) {
             bytes32 result = log.topics[1];
             // contractAddress and user topics are ignored
-            (bytes memory ciphertext,) = abi.decode(log.data, (bytes, uint256));
+            (, bytes memory ciphertext,) = abi.decode(log.data, (int32, bytes, uint256));
             handleEInput(result, ciphertext);
         }
     }

package/src/libs/incoLightning_devnet_v1_887305889.sol

@@ -1,453 +0,0 @@
-// 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} from "../IncoLightning.sol";
-import {ebool, euint256, eaddress, ETypes} from "../Types.sol";
-
-IncoLightning constant inco = IncoLightning(0x7b98b0482099611B0ebEA0F98f81FF555406794A);
-address constant deployedBy = 0x8202D2D747784Cb7D48868E44C42C4bf162a70BC;
-
-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)) {
-            return asEuint256(0);
-        }
-        return a;
-    }
-
-    function sanitize(ebool a) internal returns (ebool) {
-        if (ebool.unwrap(a) == bytes32(0)) {
-            return asEbool(false);
-        }
-        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);
-    }
-
-    function s(ebool a) internal returns (ebool) {
-        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));
-    }
-
-    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(euint256.unwrap(s(a)), euint256.unwrap(s(b)));
-    }
-
-    function eq(euint256 a, uint256 b) internal returns (ebool) {
-        return inco.eEq(euint256.unwrap(s(a)), euint256.unwrap(asEuint256(b)));
-    }
-
-    function eq(uint256 a, euint256 b) internal returns (ebool) {
-        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(euint256.unwrap(s(a)), euint256.unwrap(s(b)));
-    }
-
-    function ne(euint256 a, uint256 b) internal returns (ebool) {
-        return inco.eNe(euint256.unwrap(s(a)), euint256.unwrap(asEuint256(b)));
-    }
-
-    function ne(uint256 a, euint256 b) internal returns (ebool) {
-        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) {
-        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 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));
-    }
-
-    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 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);
-    }
-
-    function allow(ebool a, address to) internal {
-        inco.allow(ebool.unwrap(a), to);
-    }
-
-    function allow(eaddress a, address to) internal {
-        inco.allow(eaddress.unwrap(a), to);
-    }
-
-    function reveal(euint256 a) internal {
-        inco.reveal(euint256.unwrap(a));
-    }
-
-    function reveal(ebool a) internal {
-        inco.reveal(ebool.unwrap(a));
-    }
-
-    function reveal(eaddress a) internal {
-        inco.reveal(eaddress.unwrap(a));
-    }
-
-    function allowThis(euint256 a) internal {
-        allow(a, address(this));
-    }
-
-    function allowThis(ebool a) internal {
-        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);
-    }
-
-    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, eaddress ifTrue, eaddress ifFalse) internal returns (eaddress) {
-        return eaddress.wrap(inco.eIfThenElse(s(control), eaddress.unwrap(s(ifTrue)), eaddress.unwrap(s(ifFalse))));
-    }
-
-}

package/src/libs/incoLightning_testnet_v1_938327937.sol

@@ -1,453 +0,0 @@
-// 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} from "../IncoLightning.sol";
-import {ebool, euint256, eaddress, ETypes} from "../Types.sol";
-
-IncoLightning constant inco = IncoLightning(0xFb0Bd1a97DD2ECA4c7560b2a35d56474593f3Bab);
-address constant deployedBy = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;
-
-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)) {
-            return asEuint256(0);
-        }
-        return a;
-    }
-
-    function sanitize(ebool a) internal returns (ebool) {
-        if (ebool.unwrap(a) == bytes32(0)) {
-            return asEbool(false);
-        }
-        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);
-    }
-
-    function s(ebool a) internal returns (ebool) {
-        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));
-    }
-
-    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(euint256.unwrap(s(a)), euint256.unwrap(s(b)));
-    }
-
-    function eq(euint256 a, uint256 b) internal returns (ebool) {
-        return inco.eEq(euint256.unwrap(s(a)), euint256.unwrap(asEuint256(b)));
-    }
-
-    function eq(uint256 a, euint256 b) internal returns (ebool) {
-        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(euint256.unwrap(s(a)), euint256.unwrap(s(b)));
-    }
-
-    function ne(euint256 a, uint256 b) internal returns (ebool) {
-        return inco.eNe(euint256.unwrap(s(a)), euint256.unwrap(asEuint256(b)));
-    }
-
-    function ne(uint256 a, euint256 b) internal returns (ebool) {
-        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) {
-        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 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));
-    }
-
-    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 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);
-    }
-
-    function allow(ebool a, address to) internal {
-        inco.allow(ebool.unwrap(a), to);
-    }
-
-    function allow(eaddress a, address to) internal {
-        inco.allow(eaddress.unwrap(a), to);
-    }
-
-    function reveal(euint256 a) internal {
-        inco.reveal(euint256.unwrap(a));
-    }
-
-    function reveal(ebool a) internal {
-        inco.reveal(ebool.unwrap(a));
-    }
-
-    function reveal(eaddress a) internal {
-        inco.reveal(eaddress.unwrap(a));
-    }
-
-    function allowThis(euint256 a) internal {
-        allow(a, address(this));
-    }
-
-    function allowThis(ebool a) internal {
-        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);
-    }
-
-    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, eaddress ifTrue, eaddress ifFalse) internal returns (eaddress) {
-        return eaddress.wrap(inco.eIfThenElse(s(control), eaddress.unwrap(s(ifTrue)), eaddress.unwrap(s(ifFalse))));
-    }
-
-}