@inco/lightning 0.1.20

package/src/pasted-dependencies/ICreateX.sol

@@ -0,0 +1,187 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.4;
+
+/**
+ * @title CreateX Factory Interface Definition
+ * @author pcaversaccio (https://web.archive.org/web/20230921103111/https://pcaversaccio.com/)
+ * @custom:coauthor Matt Solomon (https://web.archive.org/web/20230921103335/https://mattsolomon.dev/)
+ */
+interface ICreateX {
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                            TYPES                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    struct Values {
+        uint256 constructorAmount;
+        uint256 initCallAmount;
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           EVENTS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    event ContractCreation(address indexed newContract, bytes32 indexed salt);
+    event ContractCreation(address indexed newContract);
+    event Create3ProxyContractCreation(
+        address indexed newContract,
+        bytes32 indexed salt
+    );
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                        CUSTOM ERRORS                       */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    error FailedContractCreation(address emitter);
+    error FailedContractInitialisation(address emitter, bytes revertData);
+    error InvalidSalt(address emitter);
+    error InvalidNonceValue(address emitter);
+    error FailedEtherTransfer(address emitter, bytes revertData);
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           CREATE                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function deployCreate(
+        bytes memory initCode
+    ) external payable returns (address newContract);
+
+    function deployCreateAndInit(
+        bytes memory initCode,
+        bytes memory data,
+        Values memory values,
+        address refundAddress
+    ) external payable returns (address newContract);
+
+    function deployCreateAndInit(
+        bytes memory initCode,
+        bytes memory data,
+        Values memory values
+    ) external payable returns (address newContract);
+
+    function deployCreateClone(
+        address implementation,
+        bytes memory data
+    ) external payable returns (address proxy);
+
+    function computeCreateAddress(
+        address deployer,
+        uint256 nonce
+    ) external view returns (address computedAddress);
+
+    function computeCreateAddress(
+        uint256 nonce
+    ) external view returns (address computedAddress);
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           CREATE2                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function deployCreate2(
+        bytes32 salt,
+        bytes memory initCode
+    ) external payable returns (address newContract);
+
+    function deployCreate2(
+        bytes memory initCode
+    ) external payable returns (address newContract);
+
+    function deployCreate2AndInit(
+        bytes32 salt,
+        bytes memory initCode,
+        bytes memory data,
+        Values memory values,
+        address refundAddress
+    ) external payable returns (address newContract);
+
+    function deployCreate2AndInit(
+        bytes32 salt,
+        bytes memory initCode,
+        bytes memory data,
+        Values memory values
+    ) external payable returns (address newContract);
+
+    function deployCreate2AndInit(
+        bytes memory initCode,
+        bytes memory data,
+        Values memory values,
+        address refundAddress
+    ) external payable returns (address newContract);
+
+    function deployCreate2AndInit(
+        bytes memory initCode,
+        bytes memory data,
+        Values memory values
+    ) external payable returns (address newContract);
+
+    function deployCreate2Clone(
+        bytes32 salt,
+        address implementation,
+        bytes memory data
+    ) external payable returns (address proxy);
+
+    function deployCreate2Clone(
+        address implementation,
+        bytes memory data
+    ) external payable returns (address proxy);
+
+    function computeCreate2Address(
+        bytes32 salt,
+        bytes32 initCodeHash,
+        address deployer
+    ) external pure returns (address computedAddress);
+
+    function computeCreate2Address(
+        bytes32 salt,
+        bytes32 initCodeHash
+    ) external view returns (address computedAddress);
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           CREATE3                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function deployCreate3(
+        bytes32 salt,
+        bytes memory initCode
+    ) external payable returns (address newContract);
+
+    function deployCreate3(
+        bytes memory initCode
+    ) external payable returns (address newContract);
+
+    function deployCreate3AndInit(
+        bytes32 salt,
+        bytes memory initCode,
+        bytes memory data,
+        Values memory values,
+        address refundAddress
+    ) external payable returns (address newContract);
+
+    function deployCreate3AndInit(
+        bytes32 salt,
+        bytes memory initCode,
+        bytes memory data,
+        Values memory values
+    ) external payable returns (address newContract);
+
+    function deployCreate3AndInit(
+        bytes memory initCode,
+        bytes memory data,
+        Values memory values,
+        address refundAddress
+    ) external payable returns (address newContract);
+
+    function deployCreate3AndInit(
+        bytes memory initCode,
+        bytes memory data,
+        Values memory values
+    ) external payable returns (address newContract);
+
+    function computeCreate3Address(
+        bytes32 salt,
+        address deployer
+    ) external pure returns (address computedAddress);
+
+    function computeCreate3Address(
+        bytes32 salt
+    ) external view returns (address computedAddress);
+}

package/src/test/AddTwo.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {e, euint256} from "../Lib.sol";
+
+contract AddTwo {
+    using e for euint256;
+    using e for uint256;
+    using e for bytes;
+
+    // Stores the result of the last callback.
+    uint256 public lastResult;
+
+    function addTwo(euint256 a) external returns (euint256) {
+        uint256 two = 2;
+        return a.add(two.asEuint256());
+    }
+
+    function addTwoScalar(euint256 a) external returns (euint256) {
+        uint256 two = 2;
+        return a.add(two);
+    }
+
+    // addTwoEOA is the equivalent of addTwo, but it allows an EOA to call it
+    // with an encrypted input.
+    function addTwoEOA(
+        bytes memory uint256EInput
+    ) external returns (uint256, euint256) {
+        euint256 value = uint256EInput.newEuint256(msg.sender);
+        euint256 result = this.addTwo(value);
+        e.allow(result, address(this));
+        e.allow(result, msg.sender);
+        uint256 requestId = e.requestDecryption(
+            result,
+            this.callback.selector,
+            ""
+        );
+        return (requestId, result);
+    }
+
+    function callback(
+        uint256 /* requestId */,
+        uint256 result,
+        bytes memory /* data */
+    ) external {
+        lastResult = result;
+    }
+}

package/src/test/FakeIncoInfra/FakeComputeServer.sol

@@ -0,0 +1,137 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {EOps, ETypes} from "../../Types.sol";
+import {asBytes32} from "@inco/shared/src/TypeUtils.sol";
+
+contract FakeComputeServer {
+    function computeBinaryUintOp(
+        uint256 lhs,
+        uint256 rhs,
+        EOps op
+    ) internal pure returns (uint256) {
+        if (op == EOps.Add) {
+            return lhs + rhs;
+        } else if (op == EOps.Sub) {
+            return lhs - rhs;
+        } else if (op == EOps.Mul) {
+            return lhs * rhs;
+        } else if (op == EOps.Div) {
+            return lhs / rhs;
+        } else if (op == EOps.Rem) {
+            return lhs % rhs;
+        } else if (op == EOps.Min) {
+            return lhs < rhs ? lhs : rhs;
+        } else if (op == EOps.Max) {
+            return lhs > rhs ? lhs : rhs;
+        } else if (op == EOps.BitAnd) {
+            return lhs & rhs;
+        } else if (op == EOps.BitOr) {
+            return lhs | rhs;
+        } else if (op == EOps.BitXor) {
+            return lhs ^ rhs;
+        } else if (op == EOps.Shl) {
+            return lhs << rhs;
+        } else if (op == EOps.Shr) {
+            return lhs >> rhs;
+        } else if (op == EOps.Rotl) {
+            return (lhs << rhs) | (lhs >> (256 - rhs));
+        } else if (op == EOps.Rotr) {
+            return (lhs >> rhs) | (lhs << (256 - rhs));
+        } else {
+            revert("computeBinaryUintOp Invalid binary uint op");
+        }
+    }
+
+    function computeBinaryUintToBoolOp(
+        uint256 lhs,
+        uint256 rhs,
+        EOps op
+    ) internal pure returns (bool) {
+        if (op == EOps.Eq) {
+            return lhs == rhs;
+        } else if (op == EOps.Ne) {
+            return lhs != rhs;
+        } else if (op == EOps.Ge) {
+            return lhs >= rhs;
+        } else if (op == EOps.Gt) {
+            return lhs > rhs;
+        } else if (op == EOps.Le) {
+            return lhs <= rhs;
+        } else if (op == EOps.Lt) {
+            return lhs < rhs;
+        } else {
+            revert("computeBinaryUintToBoolOp Invalid binary uint to bool op");
+        }
+    }
+
+    function isBinaryUintToUintOp(EOps op) internal pure returns (bool) {
+        return
+            op == EOps.Add ||
+            op == EOps.Sub ||
+            op == EOps.Mul ||
+            op == EOps.Div ||
+            op == EOps.Rem ||
+            op == EOps.Min ||
+            op == EOps.Max ||
+            op == EOps.BitAnd ||
+            op == EOps.BitOr ||
+            op == EOps.BitXor ||
+            op == EOps.Shl ||
+            op == EOps.Shr ||
+            op == EOps.Rotl ||
+            op == EOps.Rotr;
+    }
+
+    function isBinaryUintToBoolOp(EOps op) internal pure returns (bool) {
+        return
+            op == EOps.Eq ||
+            op == EOps.Ne ||
+            op == EOps.Ge ||
+            op == EOps.Gt ||
+            op == EOps.Le ||
+            op == EOps.Lt;
+    }
+
+    function opToResultType(EOps op) internal pure returns (ETypes) {
+        if (isBinaryUintToUintOp(op)) {
+            return ETypes.Uint256;
+        } else if (isBinaryUintToBoolOp(op)) {
+            return ETypes.Bool;
+        } else {
+            revert("opToResultType Invalid op");
+        }
+    }
+
+    function isBinaryUintOp(EOps op) internal pure returns (bool) {
+        return isBinaryUintToUintOp(op) || isBinaryUintToBoolOp(op);
+    }
+
+    function computeBinaryOp(
+        bytes32 encodedLhs,
+        bytes32 encodedRhs,
+        EOps op
+    ) internal pure returns (bytes32) {
+        if (isBinaryUintToUintOp(op)) {
+            return
+                bytes32(
+                    computeBinaryUintOp(
+                        uint256(encodedLhs),
+                        uint256(encodedRhs),
+                        op
+                    )
+                );
+        } else if (isBinaryUintToBoolOp(op)) {
+            return
+                asBytes32(
+                    computeBinaryUintToBoolOp(
+                        uint256(encodedLhs),
+                        uint256(encodedRhs),
+                        op
+                    )
+                );
+        } else {
+            revert("computeBinaryOp Invalid binary op");
+        }
+    }
+}

package/src/test/FakeIncoInfra/FakeIncoInfraBase.sol

@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {ebool, euint256, ETypes} from "../../Types.sol";
+import {inco} from "../../Lib.sol";
+import {Vm} from "forge-std/Test.sol";
+import {TestUtils} from "@inco/shared/src/TestUtils.sol";
+import {DecryptionResult} from "../../lightning-parts/DecryptionHandler.sol";
+import {KVStore} from "./KVStore.sol";
+
+/// @notice simulates what inco does offchain but over plaintexts
+contract FakeIncoInfraBase is TestUtils, KVStore {
+    error UnsupportedTypeInput(ETypes inputType);
+
+    address immutable teePubkeyAddress;
+    uint256 immutable teePrivKey;
+
+    constructor() {
+        (teePrivKey, teePubkeyAddress) = getLabeledKeyPair("tee");
+    }
+
+    function handleDecryptionRequest(
+        uint256 requestId,
+        bytes32 handle
+    ) internal {
+        DecryptionResult memory result = DecryptionResult({
+            abiEncodedResult: get(handle),
+            requestId: requestId
+        });
+        vm.prank(teePubkeyAddress);
+        inco.fulfillRequest(result, "");
+    }
+
+    function fakePrepareEuint256Ciphertext(
+        uint256 value
+    ) internal pure returns (bytes memory ciphertext) {
+        ciphertext = abi.encode(value);
+    }
+
+    function fakeDecryptEuint256Ciphertext(
+        bytes memory ciphertext
+    ) internal pure returns (uint256 value) {
+        value = abi.decode(ciphertext, (uint256));
+    }
+
+    function fakePrepareEboolCiphertext(
+        bool value
+    ) internal pure returns (bytes memory ciphertext) {
+        ciphertext = abi.encode(value);
+    }
+
+    function fakeDecryptEboolCiphertext(
+        bytes memory ciphertext
+    ) internal pure returns (bool value) {
+        value = abi.decode(ciphertext, (bool));
+    }
+
+    function fakeEncryptBool(bool value) internal pure returns (ebool) {
+        return ebool.wrap(bytes32(value ? uint256(1) : uint256(0)));
+    }
+
+    function fakeEncryptUint256(
+        uint256 value
+    ) internal pure returns (euint256) {
+        return euint256.wrap(bytes32(value));
+    }
+
+    function fakeDecryptEbool(ebool handle) internal pure returns (bool) {
+        return ebool.unwrap(handle) == bytes32(uint256(1));
+    }
+
+    function fakeDecryptEuint256(
+        euint256 handle
+    ) internal pure returns (uint256) {
+        return uint256(euint256.unwrap(handle));
+    }
+}

package/src/test/FakeIncoInfra/KVStore.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {HandleMetadata} from "../../lightning-parts/primitives/HandleMetadata.sol";
+import {ETypes, euint256, ebool} from "../../Types.sol";
+import {asBool} from "@inco/shared/src/TypeUtils.sol";
+
+/// @notice key-value store, knows the value behind each handle
+contract KVStore is HandleMetadata {
+    mapping(bytes32 => bytes32) private store;
+
+    function set(bytes32 key, bytes32 value) internal {
+        store[key] = value;
+    }
+
+    function get(bytes32 key) internal view returns (bytes32) {
+        return store[key];
+    }
+
+    function getUint256Value(euint256 input) internal view returns (uint256) {
+        bytes32 handle = euint256.unwrap(input);
+        checkType(handle, ETypes.Uint256);
+        return uint256(get(handle));
+    }
+
+    function getBoolValue(ebool input) internal view returns (bool) {
+        bytes32 handle = ebool.unwrap(input);
+        checkType(handle, ETypes.Bool);
+        return asBool(get(handle));
+    }
+
+    function checkType(bytes32 handle, ETypes requiredType) private pure {
+        assert(typeOf(handle) == requiredType);
+    }
+}

package/src/test/FakeIncoInfra/MockOpHandler.sol

@@ -0,0 +1,140 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {Vm} from "forge-std/Test.sol";
+import {inco} from "../../Lib.sol";
+import {ebool, euint256, ETypes, EOps} from "../../Types.sol";
+import {DecryptionRequested} from "../../lightning-parts/DecryptionHandler.sol";
+import {FakeComputeServer} from "./FakeComputeServer.sol";
+import {FakeIncoInfraBase} from "./FakeIncoInfraBase.sol";
+import {asBytes32} from "@inco/shared/src/TypeUtils.sol";
+import {getOpForSelector} from "./getOpForSelector.sol";
+
+contract MockOpHandler is FakeIncoInfraBase, FakeComputeServer {
+    function processAllOperations() internal {
+        Vm.Log[] memory logs = vm.getRecordedLogs();
+        for (uint256 i = 0; i < logs.length; i++) {
+            if (logs[i].emitter == address(inco)) {
+                handleIncoLog(logs[i]);
+            }
+        }
+    }
+
+    function handleIncoLog(Vm.Log memory log) internal {
+        bytes32 eventSelector = log.topics[0];
+        EOps op = getOpForSelector(eventSelector);
+        if (op == EOps.TrivialEncrypt) {
+            bytes32 result = log.topics[1];
+            (bytes32 plainTextBytes, , ) = abi.decode(
+                log.data,
+                (bytes32, ETypes, uint256)
+            );
+            handleTrivialEncryption(result, plainTextBytes);
+        } else if (isBinaryUintOp(op)) {
+            bytes32 lhs = log.topics[1];
+            bytes32 rhs = log.topics[2];
+            bytes32 result = log.topics[3];
+            set(result, computeBinaryOp(get(lhs), get(rhs), op));
+        } else if (op == EOps.IfThenElse) {
+            bytes memory logData = log.data;
+            ebool control;
+            bytes32 ifTrue = log.topics[1];
+            bytes32 ifFalse = log.topics[2];
+            bytes32 result = log.topics[3];
+            assembly {
+                control := mload(add(logData, 0x20))
+            }
+            handleIfThenElse(control, ifTrue, ifFalse, result);
+        } else if (op == EOps.Not) {
+            ebool value = ebool.wrap(log.topics[1]);
+            ebool result = ebool.wrap(log.topics[2]);
+            handleENot(value, result);
+        } else if (op == EOps.Rand) {
+            uint256 counter = uint256(log.topics[1]);
+            euint256 result = euint256.wrap(log.topics[2]);
+            handleERand(counter, result);
+        } else if (op == EOps.RandBounded) {
+            uint256 counter = uint256(log.topics[1]);
+            euint256 upperBound = euint256.wrap(log.topics[2]);
+            euint256 result = euint256.wrap(log.topics[3]);
+            handleERandBounded(counter, upperBound, result);
+        } else if (op == EOps.Cast) {
+            bytes32 ct = log.topics[1];
+            uint8 toType = uint8(uint256(log.topics[2]));
+            bytes32 result = log.topics[3];
+            handleECast(ct, toType, result);
+        } else if (op == EOps.NewInput) {
+            bytes32 result = log.topics[1];
+            // contractAddress and user topics are ignored
+            (ETypes inputType, bytes memory ciphertext, ) = abi.decode(
+                log.data,
+                (ETypes, bytes, uint256)
+            );
+            handleEInput(result, inputType, ciphertext);
+        } else if (op == EOps.DecryptionRequested) {
+            uint256 requestId = uint256(log.topics[1]);
+            bytes32 handle = log.topics[2];
+            // other fields ignored for now
+            // todo cheats to trigger decryption later
+            handleDecryptionRequest(requestId, handle);
+        }
+    }
+
+    function handleEInput(
+        bytes32 result,
+        ETypes inputType,
+        bytes memory ciphertext
+    ) private {
+        if (inputType == ETypes.Uint256) {
+            set(result, bytes32(fakeDecryptEuint256Ciphertext(ciphertext)));
+        } else if (inputType == ETypes.Bool) {
+            set(result, asBytes32(fakeDecryptEboolCiphertext(ciphertext)));
+        } else {
+            revert UnsupportedTypeInput(inputType);
+        }
+    }
+
+    function handleENot(ebool value, ebool result) private {
+        set(ebool.unwrap(result), asBytes32(!getBoolValue(value)));
+    }
+
+    function handleERand(uint256 counter, euint256 result) private {
+        set(euint256.unwrap(result), bytes32(counter));
+    }
+
+    function handleERandBounded(
+        uint256 counter,
+        euint256 upperBound,
+        euint256 result
+    ) private {
+        set(
+            euint256.unwrap(result),
+            bytes32(counter % getUint256Value(upperBound))
+        );
+    }
+
+    function handleIfThenElse(
+        ebool control,
+        bytes32 lhs,
+        bytes32 rhs,
+        bytes32 result
+    ) private {
+        set(result, bytes32(getBoolValue(control) ? get(lhs) : get(rhs)));
+    }
+
+    function handleECast(bytes32 handle, uint8 toType, bytes32 result) private {
+        ETypes _toType = ETypes(toType);
+        if (_toType == ETypes.Bool || _toType == ETypes.Uint256) {
+            set(result, get(handle));
+        } else {
+            revert UnsupportedTypeInput(ETypes(toType));
+        }
+    }
+
+    function handleTrivialEncryption(
+        bytes32 result,
+        bytes32 plainTextBytes
+    ) private {
+        set(result, plainTextBytes);
+    }
+}

package/src/test/FakeIncoInfra/getOpForSelector.sol

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {DecryptionRequested} from "../../lightning-parts/DecryptionHandler.sol";
+import {EncryptedOperations} from "../../lightning-parts/EncryptedOperations.sol";
+import {TrivialEncryption} from "../../lightning-parts/TrivialEncryption.sol";
+import {EncryptedInput} from "../../lightning-parts/EncryptedInput.sol";
+import {EOps} from "../../Types.sol";
+
+// letting this func alone in its file as multiple of this type gets unreadable fast
+function getOpForSelector(bytes32 opEventSelector) pure returns (EOps) {
+    if (opEventSelector == EncryptedOperations.EAdd.selector) {
+        return EOps.Add;
+    } else if (opEventSelector == EncryptedOperations.ESub.selector) {
+        return EOps.Sub;
+    } else if (opEventSelector == EncryptedOperations.EMul.selector) {
+        return EOps.Mul;
+    } else if (opEventSelector == EncryptedOperations.EDiv.selector) {
+        return EOps.Div;
+    } else if (opEventSelector == EncryptedOperations.ERem.selector) {
+        return EOps.Rem;
+    } else if (opEventSelector == EncryptedOperations.EBitAnd.selector) {
+        return EOps.BitAnd;
+    } else if (opEventSelector == EncryptedOperations.EBitOr.selector) {
+        return EOps.BitOr;
+    } else if (opEventSelector == EncryptedOperations.EBitXor.selector) {
+        return EOps.BitXor;
+    } else if (opEventSelector == EncryptedOperations.EShl.selector) {
+        return EOps.Shl;
+    } else if (opEventSelector == EncryptedOperations.EShr.selector) {
+        return EOps.Shr;
+    } else if (opEventSelector == EncryptedOperations.ERotl.selector) {
+        return EOps.Rotl;
+    } else if (opEventSelector == EncryptedOperations.ERotr.selector) {
+        return EOps.Rotr;
+    } else if (opEventSelector == EncryptedOperations.EEq.selector) {
+        return EOps.Eq;
+    } else if (opEventSelector == EncryptedOperations.ENe.selector) {
+        return EOps.Ne;
+    } else if (opEventSelector == EncryptedOperations.EGe.selector) {
+        return EOps.Ge;
+    } else if (opEventSelector == EncryptedOperations.EGt.selector) {
+        return EOps.Gt;
+    } else if (opEventSelector == EncryptedOperations.ELe.selector) {
+        return EOps.Le;
+    } else if (opEventSelector == EncryptedOperations.ELt.selector) {
+        return EOps.Lt;
+    } else if (opEventSelector == EncryptedOperations.EMin.selector) {
+        return EOps.Min;
+    } else if (opEventSelector == EncryptedOperations.EMax.selector) {
+        return EOps.Max;
+    } else if (opEventSelector == EncryptedOperations.ENot.selector) {
+        return EOps.Not;
+    } else if (opEventSelector == EncryptedInput.NewInput.selector) {
+        return EOps.NewInput;
+    } else if (opEventSelector == EncryptedOperations.ECast.selector) {
+        return EOps.Cast;
+    } else if (opEventSelector == TrivialEncryption.TrivialEncrypt.selector) {
+        return EOps.TrivialEncrypt;
+    } else if (opEventSelector == EncryptedOperations.EIfThenElse.selector) {
+        return EOps.IfThenElse;
+    } else if (opEventSelector == EncryptedOperations.ERand.selector) {
+        return EOps.Rand;
+    } else if (opEventSelector == EncryptedOperations.ERandBounded.selector) {
+        return EOps.RandBounded;
+    } else if (opEventSelector == DecryptionRequested.selector) {
+        return EOps.DecryptionRequested;
+    } else {
+        revert("getOpForSelector: Unsupported selector");
+    }
+}