@inco/lightning 0.8.0-devnet-28 → 0.8.0-devnet-30

package/src/libs/incoLightning_devnet_v8_985328058.sol

@@ -6,7 +6,8 @@
 pragma solidity ^0.8;
 
 import { IncoLightning } from "../IncoLightning.sol";
-import { ebool, euint256, eaddress, ETypes, elist, IndexOutOfRange, InvalidRange, SliceOutOfRange, UnsupportedListType } from "../Types.sol";
+import { ebool, euint256, eaddress, ETypes, elist, IndexOutOfRange, InvalidRange, SliceOutOfRange, UnsupportedListType, HandleMismatch, InvalidTEEAttestation, UnexpectedDecryptedValue } from "../Types.sol";
+import { asBool } from "../shared/TypeUtils.sol";
 import { DecryptionAttestation, ElementAttestationWithProof } from "../lightning-parts/DecryptionAttester.types.sol";
 
 IncoLightning constant inco = IncoLightning(payable(0x43119Ad1F673E998CE4f3BB305bB92Bd5ab97E3B));
@@ -687,7 +688,8 @@ library e {
     ///  @dev costs the inco fee
     ///  @return The encrypted random value
     function rand() internal returns (euint256) {
-        bytes32 result = _callWithFeeRetry(abi.encodeWithSelector(inco.eRand.selector, ETypes.Uint256));
+        bytes32 boundHandle = euint256.unwrap(asEuint256(0));
+        bytes32 result = _callWithFeeRetry(abi.encodeWithSelector(inco.eRandBounded.selector, boundHandle, ETypes.Uint256));
         return euint256.wrap(result);
     }
 
@@ -1194,4 +1196,28 @@ library e {
     function verifyEListDecryption(elist elistHandle, ElementAttestationWithProof[] memory proofElements, bytes32 proof, bytes[] memory signatures) internal view returns (bool) {
         return inco.incoVerifier().isValidEListDecryptionAttestation(elist.unwrap(elistHandle), proofElements, proof, signatures);
     }
+
+    ///  @notice Checks a decryption attestation for an encrypted bool against an expected plaintext value
+    ///  @param handle The encrypted handle
+    ///  @param expected The expected plaintext value
+    ///  @param decryption The decryption attestation to verify
+    ///  @param signatures The covalidator signatures for the attestation
+    ///  @dev Reverts if the handle doesn't match, the decrypted value doesn't match the expected value, or the attestation is invalid
+    function requireEqual(ebool handle, bool expected, DecryptionAttestation memory decryption, bytes[] memory signatures) internal view {
+        require(ebool.unwrap(handle) == decryption.handle, HandleMismatch());
+        require(asBool(decryption.value) == expected, UnexpectedDecryptedValue());
+        require(inco.incoVerifier().isValidDecryptionAttestation(decryption, signatures), InvalidTEEAttestation());
+    }
+
+    ///  @notice Checks a decryption attestation for an encrypted uint256 against an expected plaintext value
+    ///  @param handle The encrypted handle
+    ///  @param expected The expected plaintext value
+    ///  @param decryption The decryption attestation to verify
+    ///  @param signatures The covalidator signatures for the attestation
+    ///  @dev Reverts if the handle doesn't match, the decrypted value doesn't match the expected value, or the attestation is invalid
+    function requireEqual(euint256 handle, uint256 expected, DecryptionAttestation memory decryption, bytes[] memory signatures) internal view {
+        require(euint256.unwrap(handle) == decryption.handle, HandleMismatch());
+        require(uint256(decryption.value) == expected, UnexpectedDecryptedValue());
+        require(inco.incoVerifier().isValidDecryptionAttestation(decryption, signatures), InvalidTEEAttestation());
+    }
 }

package/src/libs/incoLightning_devnet_v9_269218568.sol

@@ -6,7 +6,8 @@
 pragma solidity ^0.8;
 
 import { IncoLightning } from "../IncoLightning.sol";
-import { ebool, euint256, eaddress, ETypes, elist, IndexOutOfRange, InvalidRange, SliceOutOfRange, UnsupportedListType } from "../Types.sol";
+import { ebool, euint256, eaddress, ETypes, elist, IndexOutOfRange, InvalidRange, SliceOutOfRange, UnsupportedListType, HandleMismatch, InvalidTEEAttestation, UnexpectedDecryptedValue } from "../Types.sol";
+import { asBool } from "../shared/TypeUtils.sol";
 import { DecryptionAttestation, ElementAttestationWithProof } from "../lightning-parts/DecryptionAttester.types.sol";
 
 IncoLightning constant inco = IncoLightning(payable(0x6c9132D324231D2F68a1491686b0d4c10ee7d257));
@@ -687,7 +688,8 @@ library e {
     ///  @dev costs the inco fee
     ///  @return The encrypted random value
     function rand() internal returns (euint256) {
-        bytes32 result = _callWithFeeRetry(abi.encodeWithSelector(inco.eRand.selector, ETypes.Uint256));
+        bytes32 boundHandle = euint256.unwrap(asEuint256(0));
+        bytes32 result = _callWithFeeRetry(abi.encodeWithSelector(inco.eRandBounded.selector, boundHandle, ETypes.Uint256));
         return euint256.wrap(result);
     }
 
@@ -1194,4 +1196,28 @@ library e {
     function verifyEListDecryption(elist elistHandle, ElementAttestationWithProof[] memory proofElements, bytes32 proof, bytes[] memory signatures) internal view returns (bool) {
         return inco.incoVerifier().isValidEListDecryptionAttestation(elist.unwrap(elistHandle), proofElements, proof, signatures);
     }
+
+    ///  @notice Checks a decryption attestation for an encrypted bool against an expected plaintext value
+    ///  @param handle The encrypted handle
+    ///  @param expected The expected plaintext value
+    ///  @param decryption The decryption attestation to verify
+    ///  @param signatures The covalidator signatures for the attestation
+    ///  @dev Reverts if the handle doesn't match, the decrypted value doesn't match the expected value, or the attestation is invalid
+    function requireEqual(ebool handle, bool expected, DecryptionAttestation memory decryption, bytes[] memory signatures) internal view {
+        require(ebool.unwrap(handle) == decryption.handle, HandleMismatch());
+        require(asBool(decryption.value) == expected, UnexpectedDecryptedValue());
+        require(inco.incoVerifier().isValidDecryptionAttestation(decryption, signatures), InvalidTEEAttestation());
+    }
+
+    ///  @notice Checks a decryption attestation for an encrypted uint256 against an expected plaintext value
+    ///  @param handle The encrypted handle
+    ///  @param expected The expected plaintext value
+    ///  @param decryption The decryption attestation to verify
+    ///  @param signatures The covalidator signatures for the attestation
+    ///  @dev Reverts if the handle doesn't match, the decrypted value doesn't match the expected value, or the attestation is invalid
+    function requireEqual(euint256 handle, uint256 expected, DecryptionAttestation memory decryption, bytes[] memory signatures) internal view {
+        require(euint256.unwrap(handle) == decryption.handle, HandleMismatch());
+        require(uint256(decryption.value) == expected, UnexpectedDecryptedValue());
+        require(inco.incoVerifier().isValidDecryptionAttestation(decryption, signatures), InvalidTEEAttestation());
+    }
 }

package/src/libs/incoLightning_testnet_v0_183408998.sol

@@ -6,7 +6,8 @@
 pragma solidity ^0.8;
 
 import { IncoLightning } from "../IncoLightning.sol";
-import { ebool, euint256, eaddress, ETypes, elist, IndexOutOfRange, InvalidRange, SliceOutOfRange, UnsupportedListType } from "../Types.sol";
+import { ebool, euint256, eaddress, ETypes, elist, IndexOutOfRange, InvalidRange, SliceOutOfRange, UnsupportedListType, HandleMismatch, InvalidTEEAttestation, UnexpectedDecryptedValue } from "../Types.sol";
+import { asBool } from "../shared/TypeUtils.sol";
 import { DecryptionAttestation, ElementAttestationWithProof } from "../lightning-parts/DecryptionAttester.types.sol";
 
 IncoLightning constant inco = IncoLightning(payable(0x63D8135aF4D393B1dB43B649010c8D3EE19FC9fd));
@@ -687,7 +688,8 @@ library e {
     ///  @dev costs the inco fee
     ///  @return The encrypted random value
     function rand() internal returns (euint256) {
-        bytes32 result = _callWithFeeRetry(abi.encodeWithSelector(inco.eRand.selector, ETypes.Uint256));
+        bytes32 boundHandle = euint256.unwrap(asEuint256(0));
+        bytes32 result = _callWithFeeRetry(abi.encodeWithSelector(inco.eRandBounded.selector, boundHandle, ETypes.Uint256));
         return euint256.wrap(result);
     }
 
@@ -1194,4 +1196,28 @@ library e {
     function verifyEListDecryption(elist elistHandle, ElementAttestationWithProof[] memory proofElements, bytes32 proof, bytes[] memory signatures) internal view returns (bool) {
         return inco.incoVerifier().isValidEListDecryptionAttestation(elist.unwrap(elistHandle), proofElements, proof, signatures);
     }
+
+    ///  @notice Checks a decryption attestation for an encrypted bool against an expected plaintext value
+    ///  @param handle The encrypted handle
+    ///  @param expected The expected plaintext value
+    ///  @param decryption The decryption attestation to verify
+    ///  @param signatures The covalidator signatures for the attestation
+    ///  @dev Reverts if the handle doesn't match, the decrypted value doesn't match the expected value, or the attestation is invalid
+    function requireEqual(ebool handle, bool expected, DecryptionAttestation memory decryption, bytes[] memory signatures) internal view {
+        require(ebool.unwrap(handle) == decryption.handle, HandleMismatch());
+        require(asBool(decryption.value) == expected, UnexpectedDecryptedValue());
+        require(inco.incoVerifier().isValidDecryptionAttestation(decryption, signatures), InvalidTEEAttestation());
+    }
+
+    ///  @notice Checks a decryption attestation for an encrypted uint256 against an expected plaintext value
+    ///  @param handle The encrypted handle
+    ///  @param expected The expected plaintext value
+    ///  @param decryption The decryption attestation to verify
+    ///  @param signatures The covalidator signatures for the attestation
+    ///  @dev Reverts if the handle doesn't match, the decrypted value doesn't match the expected value, or the attestation is invalid
+    function requireEqual(euint256 handle, uint256 expected, DecryptionAttestation memory decryption, bytes[] memory signatures) internal view {
+        require(euint256.unwrap(handle) == decryption.handle, HandleMismatch());
+        require(uint256(decryption.value) == expected, UnexpectedDecryptedValue());
+        require(inco.incoVerifier().isValidDecryptionAttestation(decryption, signatures), InvalidTEEAttestation());
+    }
 }

package/src/libs/incoLightning_testnet_v2_889158349.sol

@@ -6,7 +6,8 @@
 pragma solidity ^0.8;
 
 import { IncoLightning } from "../IncoLightning.sol";
-import { ebool, euint256, eaddress, ETypes, elist, IndexOutOfRange, InvalidRange, SliceOutOfRange, UnsupportedListType } from "../Types.sol";
+import { ebool, euint256, eaddress, ETypes, elist, IndexOutOfRange, InvalidRange, SliceOutOfRange, UnsupportedListType, HandleMismatch, InvalidTEEAttestation, UnexpectedDecryptedValue } from "../Types.sol";
+import { asBool } from "../shared/TypeUtils.sol";
 import { DecryptionAttestation, ElementAttestationWithProof } from "../lightning-parts/DecryptionAttester.types.sol";
 
 IncoLightning constant inco = IncoLightning(payable(0x168FDc3Ae19A5d5b03614578C58974FF30FCBe92));
@@ -687,7 +688,8 @@ library e {
     ///  @dev costs the inco fee
     ///  @return The encrypted random value
     function rand() internal returns (euint256) {
-        bytes32 result = _callWithFeeRetry(abi.encodeWithSelector(inco.eRand.selector, ETypes.Uint256));
+        bytes32 boundHandle = euint256.unwrap(asEuint256(0));
+        bytes32 result = _callWithFeeRetry(abi.encodeWithSelector(inco.eRandBounded.selector, boundHandle, ETypes.Uint256));
         return euint256.wrap(result);
     }
 
@@ -1194,4 +1196,28 @@ library e {
     function verifyEListDecryption(elist elistHandle, ElementAttestationWithProof[] memory proofElements, bytes32 proof, bytes[] memory signatures) internal view returns (bool) {
         return inco.incoVerifier().isValidEListDecryptionAttestation(elist.unwrap(elistHandle), proofElements, proof, signatures);
     }
+
+    ///  @notice Checks a decryption attestation for an encrypted bool against an expected plaintext value
+    ///  @param handle The encrypted handle
+    ///  @param expected The expected plaintext value
+    ///  @param decryption The decryption attestation to verify
+    ///  @param signatures The covalidator signatures for the attestation
+    ///  @dev Reverts if the handle doesn't match, the decrypted value doesn't match the expected value, or the attestation is invalid
+    function requireEqual(ebool handle, bool expected, DecryptionAttestation memory decryption, bytes[] memory signatures) internal view {
+        require(ebool.unwrap(handle) == decryption.handle, HandleMismatch());
+        require(asBool(decryption.value) == expected, UnexpectedDecryptedValue());
+        require(inco.incoVerifier().isValidDecryptionAttestation(decryption, signatures), InvalidTEEAttestation());
+    }
+
+    ///  @notice Checks a decryption attestation for an encrypted uint256 against an expected plaintext value
+    ///  @param handle The encrypted handle
+    ///  @param expected The expected plaintext value
+    ///  @param decryption The decryption attestation to verify
+    ///  @param signatures The covalidator signatures for the attestation
+    ///  @dev Reverts if the handle doesn't match, the decrypted value doesn't match the expected value, or the attestation is invalid
+    function requireEqual(euint256 handle, uint256 expected, DecryptionAttestation memory decryption, bytes[] memory signatures) internal view {
+        require(euint256.unwrap(handle) == decryption.handle, HandleMismatch());
+        require(uint256(decryption.value) == expected, UnexpectedDecryptedValue());
+        require(inco.incoVerifier().isValidDecryptionAttestation(decryption, signatures), InvalidTEEAttestation());
+    }
 }

package/src/lightning-parts/AccessControl/interfaces/IBaseAccessControlList.sol

@@ -8,6 +8,7 @@ import {AllowanceProof} from "../AdvancedAccessControl.types.sol";
 interface IBaseAccessControlList is IVerifierAddressGetter, IEventCounter {
 
     function allow(bytes32 handle, address account) external;
+    function reveal(bytes32 handle) external;
     function allowTransient(bytes32 handle, address account) external;
     function allowedTransient(bytes32 handle, address account) external view returns (bool);
     function persistAllowed(bytes32 handle, address account) external view returns (bool);

package/src/lightning-parts/EList.sol

@@ -75,7 +75,7 @@ abstract contract EList is IEList, EncryptedOperations, EncryptedInput, EListHan
         bytes32[] memory handles = new bytes32[](inputs.length);
         for (uint256 i = 0; i < inputs.length; i++) {
             // we check payment for multiple inputs ahead of this func
-            handles[i] = newInputNotPaying(inputs[i], user, listType);
+            handles[i] = newInputNotPayingNotEmitting(inputs[i], user, listType);
         }
         return newEListFromHandles(handles, listType);
     }

package/src/lightning-parts/EncryptedInput.sol

@@ -138,6 +138,9 @@ abstract contract EncryptedInput is
         returns (bytes32 newHandle)
     {
         newHandle = _newInput(input, user, inputType);
+        // 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.
+        allowInternal(newHandle, user);
     }
 
     /// @dev Internal function to process encrypted input without fee payment.
@@ -148,6 +151,21 @@ abstract contract EncryptedInput is
     function newInputNotPaying(bytes calldata input, address user, ETypes inputType)
         internal
         returns (bytes32 newHandle)
+    {
+        newHandle = _newInput(input, user, inputType);
+        // 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.
+        allowInternal(newHandle, user);
+    }
+
+    /// @dev Internal function to process encrypted input without fee payment and without emitting events.
+    /// Used by EList for importing multiple inputs without emitting individual events for each input.
+    /// @param user The user address that encrypted the value.
+    /// @param inputType The type of encrypted value.
+    /// @return newHandle The generated handle.
+    function newInputNotPayingNotEmitting(bytes calldata input, address user, ETypes inputType)
+        internal
+        returns (bytes32 newHandle)
     {
         newHandle = _newInput(input, user, inputType);
     }
@@ -198,9 +216,6 @@ abstract contract EncryptedInput is
             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.
-        allowInternal(handle, user);
         allowTransientInternal(handle, msg.sender);
     }
 

package/src/lightning-parts/EncryptedOperations.sol

@@ -66,7 +66,6 @@ abstract contract EncryptedOperations is IEncryptedOperations, BaseAccessControl
     event ELt(euint256 indexed lhs, euint256 indexed rhs, ebool indexed result, uint256 eventId);
     event EMin(euint256 indexed lhs, euint256 indexed rhs, euint256 indexed result, uint256 eventId);
     event EMax(euint256 indexed lhs, euint256 indexed rhs, euint256 indexed result, uint256 eventId);
-    event ERand(uint256 indexed counter, ETypes randType, bytes32 indexed result, uint256 eventId);
     event ERandBounded(
         uint256 indexed counter, ETypes randType, bytes32 indexed upperBound, bytes32 indexed result, uint256 eventId
     );
@@ -416,19 +415,6 @@ abstract contract EncryptedOperations is IEncryptedOperations, BaseAccessControl
         setDigest(abi.encodePacked(result, id));
     }
 
-    /// @notice Generates an encrypted random value of the specified type.
-    /// @dev This is a paid operation.
-    /// @param randType The type of random value to generate.
-    /// @return result An encrypted random value.
-    function eRand(ETypes randType) external payable paying returns (bytes32 result) {
-        require(isTypeSupported(randType), UnsupportedType(randType));
-        randCounter++;
-        result = createResultHandle(EOps.Rand, randType, abi.encodePacked(bytes32(randCounter)));
-        uint256 id = getNextEventId();
-        emit ERand(randCounter, randType, result, id);
-        setDigest(abi.encodePacked(result, id));
-    }
-
     /// @notice Generates an encrypted random value bounded by an upper limit.
     /// @dev This is a paid operation. The result is in the range [0, upperBound).
     /// @param upperBound The encrypted upper bound (exclusive). If the upper bound is e(0), the whole bit width of randType is sampled.

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

@@ -29,7 +29,6 @@ interface IEncryptedOperations is IBaseAccessControlList, IHandleGeneration {
     function eMax(euint256 lhs, euint256 rhs) external returns (euint256 result);
     function eNot(ebool operand) external returns (ebool result);
     function eCast(bytes32 ct, ETypes toType) external returns (bytes32 result);
-    function eRand(ETypes randType) external payable returns (bytes32 result);
     function eRandBounded(bytes32 upperBound, ETypes randType) external payable returns (bytes32 result);
     function eIfThenElse(ebool condition, bytes32 ifTrue, bytes32 ifFalse) external returns (bytes32 result);
 

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

@@ -326,13 +326,6 @@ contract TestHandleMetadata is
         this.eCast(euint256.unwrap(a), unsupportedType);
     }
 
-    /// @notice Test eRand with unsupported type (line 282)
-    function testERandUnsupportedType() public {
-        ETypes unsupportedType = ETypes.Uint4UNSUPPORTED;
-        vm.expectRevert(abi.encodeWithSelector(EncryptedOperations.UnsupportedType.selector, unsupportedType));
-        this.eRand{value: FEE}(unsupportedType);
-    }
-
     /// @notice Test eRandBounded with unsupported type (line 291)
     function testERandBoundedUnsupportedType() public {
         euint256 bound = this.asEuint256(100);

package/src/test/EListTester.sol

@@ -152,6 +152,10 @@ contract ElistTester is IncoUtils {
         return list;
     }
 
+    function listReveal() public {
+        inco.reveal(elist.unwrap(list));
+    }
+
     function listReverse() public payable returns (elist) {
         uint256 typeBits = typeBitSize(ETypes(uint8(uint256(elist.unwrap(list)) >> 16)));
         list = inco.listReverse{value: uint256(inco.lengthOf(elist.unwrap(list))) * typeBits * BIT_FEE}(list);

package/src/test/FakeIncoInfra/MockOpHandler.sol

@@ -46,10 +46,6 @@ contract MockOpHandler is FakeIncoInfraBase, FakeComputeServer {
             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]);
@@ -85,12 +81,14 @@ contract MockOpHandler is FakeIncoInfraBase, FakeComputeServer {
         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)));
+        uint256 bound = getUint256Value(upperBound);
+        if (bound == 0) {
+            // upperBound of 0 means unbounded (used by rand())
+            set(euint256.unwrap(result), bytes32(counter));
+        } else {
+            set(euint256.unwrap(result), bytes32(counter % bound));
+        }
     }
 
     function handleIfThenElse(ebool control, bytes32 lhs, bytes32 rhs, bytes32 result) private {

package/src/test/FakeIncoInfra/getOpForSelector.sol

@@ -59,8 +59,6 @@ function getOpForSelector(bytes32 opEventSelector) pure returns (EOps) {
         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 == BaseAccessControlList.Allow.selector) {

package/src/test/IncoTest.sol

@@ -12,11 +12,12 @@ import {FakeQuoteVerifier} from "./FakeIncoInfra/FakeQuoteVerifier.sol";
 import {IOwnable} from "../../src/shared/IOwnable.sol";
 import {MockRemoteAttestation} from "./FakeIncoInfra/MockRemoteAttestation.sol";
 import {BootstrapResult} from "../lightning-parts/TEELifecycle.types.sol";
+import {Safe} from "safe-smart-account/Safe.sol";
+import {SafeProxyFactory} from "safe-smart-account/proxies/SafeProxyFactory.sol";
 
 contract IncoTest is MockOpHandler, DeployUtils, FakeDecryptionAttester, MockRemoteAttestation {
 
-    // forge-lint: disable-next-line(screaming-snake-case-immutable)
-    address immutable owner;
+    address owner;
     // forge-lint: disable-next-line(screaming-snake-case-immutable)
     address immutable testDeployer;
 
@@ -31,7 +32,6 @@ contract IncoTest is MockOpHandler, DeployUtils, FakeDecryptionAttester, MockRem
         0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80;
 
     constructor() {
-        owner = getLabeledAddress("owner");
         // extracted from the deploy script running as bare simulation with:
         // forge script src/script/Deploy.s.sol:Deploy
         testDeployer = deployedBy;
@@ -42,17 +42,29 @@ contract IncoTest is MockOpHandler, DeployUtils, FakeDecryptionAttester, MockRem
 
     function setUp() public virtual {
         deployCreateX();
+
+        // Create a Safe multisig (alice, bob, carol) with threshold 2 to act as owner
+        Safe master = new Safe();
+        SafeProxyFactory factory = new SafeProxyFactory();
+        address[] memory safeOwners = new address[](3);
+        safeOwners[0] = alice;
+        safeOwners[1] = bob;
+        safeOwners[2] = carol;
+        bytes memory setupData = abi.encodeWithSelector(
+            Safe.setup.selector, safeOwners, 2, address(0), bytes(""), address(0), address(0), 0, payable(address(0))
+        );
+        owner = address(Safe(payable(factory.createProxyWithNonce(address(master), setupData, 0))));
+
         vm.startPrank(testDeployer);
         vm.setEnv("SHOULD_SETUP_TEE_SIGNER", "true"); // results in a network pubkey and decrypt signer being populated in the TEE Lifecycle
         (IIncoLightning proxy,) = deployIncoLightningUsingConfig({
             deployer: testDeployer,
+            owner: owner,
             // The highest precedent deployment
             // We select the pepper that will be used that will be generated in the lib.sol (usually "testnet"), but currently "alphanet" has higher major version
             pepper: "devnet",
             quoteVerifier: new FakeQuoteVerifier()
         });
-        IOwnable(address(proxy)).transferOwnership(owner);
-        IOwnable(address(inco.incoVerifier())).transferOwnership(owner);
         vm.stopPrank();
         console.log("Deployed %s (proxy) to: %s", proxy.getName(), address(proxy));
         console.log("Generated inco address: %s", address(inco));

package/src/test/OpsTest.sol

@@ -380,8 +380,9 @@ contract OpsTest is Fee {
 
     // ============ RANDOM NUMBER GENERATION ============
 
-    function testRand() external payable returns (euint256) {
-        euint256 result = euint256.wrap(inco.eRand{value: getFee()}(ETypes.Uint256));
+    function testRandUnbounded() external payable returns (euint256) {
+        euint256 result =
+            euint256.wrap(inco.eRandBounded{value: getFee()}(euint256.unwrap(inco.asEuint256(0)), ETypes.Uint256));
         inco.allow(euint256.unwrap(result), address(this));
         inco.allow(euint256.unwrap(result), msg.sender);
         return result;

package/src/test/TestLib.t.sol

@@ -7,9 +7,12 @@ import {FEE} from "../lightning-parts/Fee.sol";
 import {
     ETypes,
     elist,
+    HandleMismatch,
     IndexOutOfRange,
     InvalidRange,
+    InvalidTEEAttestation,
     SliceOutOfRange,
+    UnexpectedDecryptedValue,
     UnsupportedListType,
     UnsupportedType
 } from "../Types.sol";
@@ -17,6 +20,27 @@ import {EncryptedOperations} from "../lightning-parts/EncryptedOperations.sol";
 import {DecryptionAttestation, ElementAttestationWithProof} from "../lightning-parts/DecryptionAttester.types.sol";
 import {AllowanceProof, AllowanceVoucher} from "../lightning-parts/AccessControl/AdvancedAccessControl.sol";
 
+/// @notice Wrapper to expose internal requireEqual as an external call so vm.expectRevert works
+contract RequireEqualCaller {
+
+    function callEbool(ebool handle, bool expected, DecryptionAttestation memory decryption, bytes[] memory signatures)
+        external
+        view
+    {
+        e.requireEqual(handle, expected, decryption, signatures);
+    }
+
+    function callEuint256(
+        euint256 handle,
+        uint256 expected,
+        DecryptionAttestation memory decryption,
+        bytes[] memory signatures
+    ) external view {
+        e.requireEqual(handle, expected, decryption, signatures);
+    }
+
+}
+
 /// @notice Tests for Lib.sol library functions to achieve 100% coverage
 /// @dev This file tests all the scalar variants and uncovered branches in the library
 contract TestLib is IncoTest {
@@ -853,7 +877,7 @@ contract TestLib is IncoTest {
         assertFalse(isValid, "Invalid value should return false");
     }
 
-    function testVerifyDecryption_Euint256_InvalidSignatures() public {
+    function testVerifyDecryption_Euint256_InvalidTEEAttestations() public {
         // Create an encrypted value
         euint256 encrypted = e.asEuint256(12345);
         processAllOperations();
@@ -925,6 +949,123 @@ contract TestLib is IncoTest {
         });
     }
 
+    // ============ REQUIRE EQUAL TESTS ============
+
+    function testRequireEqual_Ebool_ValidAttestation_True() public {
+        ebool encrypted = e.asEbool(true);
+        processAllOperations();
+
+        (DecryptionAttestation memory attestation, bytes[] memory signatures) = getDecryptionAttestation(
+            address(this), HandleWithProof({handle: ebool.unwrap(encrypted), proof: _emptyAllowanceProof()})
+        );
+
+        e.requireEqual(encrypted, true, attestation, signatures);
+    }
+
+    function testRequireEqual_Ebool_ValidAttestation_False() public {
+        ebool encrypted = e.asEbool(false);
+        processAllOperations();
+
+        (DecryptionAttestation memory attestation, bytes[] memory signatures) = getDecryptionAttestation(
+            address(this), HandleWithProof({handle: ebool.unwrap(encrypted), proof: _emptyAllowanceProof()})
+        );
+
+        e.requireEqual(encrypted, false, attestation, signatures);
+    }
+
+    function testRequireEqual_Ebool_WrongValue() public {
+        ebool encrypted = e.asEbool(true);
+        processAllOperations();
+
+        (DecryptionAttestation memory attestation, bytes[] memory signatures) = getDecryptionAttestation(
+            address(this), HandleWithProof({handle: ebool.unwrap(encrypted), proof: _emptyAllowanceProof()})
+        );
+
+        RequireEqualCaller caller = new RequireEqualCaller();
+        vm.expectRevert(abi.encodeWithSelector(UnexpectedDecryptedValue.selector));
+        caller.callEbool(encrypted, false, attestation, signatures);
+    }
+
+    function testRequireEqual_Ebool_HandleMismatch() public {
+        ebool encryptedA = e.asEbool(true);
+        ebool encryptedB = e.asEbool(false);
+        processAllOperations();
+
+        (DecryptionAttestation memory attestation, bytes[] memory signatures) = getDecryptionAttestation(
+            address(this), HandleWithProof({handle: ebool.unwrap(encryptedA), proof: _emptyAllowanceProof()})
+        );
+
+        RequireEqualCaller caller = new RequireEqualCaller();
+        vm.expectRevert(abi.encodeWithSelector(HandleMismatch.selector));
+        caller.callEbool(encryptedB, true, attestation, signatures);
+    }
+
+    function testRequireEqual_Ebool_InvalidTEEAttestations() public {
+        ebool encrypted = e.asEbool(true);
+        processAllOperations();
+
+        (DecryptionAttestation memory attestation,) = getDecryptionAttestation(
+            address(this), HandleWithProof({handle: ebool.unwrap(encrypted), proof: _emptyAllowanceProof()})
+        );
+
+        bytes[] memory invalidSignatures = new bytes[](0);
+        RequireEqualCaller caller = new RequireEqualCaller();
+        vm.expectRevert(abi.encodeWithSelector(InvalidTEEAttestation.selector));
+        caller.callEbool(encrypted, true, attestation, invalidSignatures);
+    }
+
+    function testRequireEqual_Euint256_ValidAttestation() public {
+        euint256 encrypted = e.asEuint256(12345);
+        processAllOperations();
+
+        (DecryptionAttestation memory attestation, bytes[] memory signatures) = getDecryptionAttestation(
+            address(this), HandleWithProof({handle: euint256.unwrap(encrypted), proof: _emptyAllowanceProof()})
+        );
+
+        e.requireEqual(encrypted, uint256(attestation.value), attestation, signatures);
+    }
+
+    function testRequireEqual_Euint256_WrongValue() public {
+        euint256 encrypted = e.asEuint256(12345);
+        processAllOperations();
+
+        (DecryptionAttestation memory attestation, bytes[] memory signatures) = getDecryptionAttestation(
+            address(this), HandleWithProof({handle: euint256.unwrap(encrypted), proof: _emptyAllowanceProof()})
+        );
+
+        RequireEqualCaller caller = new RequireEqualCaller();
+        vm.expectRevert(abi.encodeWithSelector(UnexpectedDecryptedValue.selector));
+        caller.callEuint256(encrypted, 99999, attestation, signatures);
+    }
+
+    function testRequireEqual_Euint256_HandleMismatch() public {
+        euint256 encryptedA = e.asEuint256(111);
+        euint256 encryptedB = e.asEuint256(222);
+        processAllOperations();
+
+        (DecryptionAttestation memory attestation, bytes[] memory signatures) = getDecryptionAttestation(
+            address(this), HandleWithProof({handle: euint256.unwrap(encryptedA), proof: _emptyAllowanceProof()})
+        );
+
+        RequireEqualCaller caller = new RequireEqualCaller();
+        vm.expectRevert(abi.encodeWithSelector(HandleMismatch.selector));
+        caller.callEuint256(encryptedB, uint256(attestation.value), attestation, signatures);
+    }
+
+    function testRequireEqual_Euint256_InvalidTEEAttestations() public {
+        euint256 encrypted = e.asEuint256(12345);
+        processAllOperations();
+
+        (DecryptionAttestation memory attestation,) = getDecryptionAttestation(
+            address(this), HandleWithProof({handle: euint256.unwrap(encrypted), proof: _emptyAllowanceProof()})
+        );
+
+        bytes[] memory invalidSignatures = new bytes[](0);
+        RequireEqualCaller caller = new RequireEqualCaller();
+        vm.expectRevert(abi.encodeWithSelector(InvalidTEEAttestation.selector));
+        caller.callEuint256(encrypted, uint256(attestation.value), attestation, invalidSignatures);
+    }
+
     // ============ ELIST PURE FUNCTION TESTS ============
     // Note: Most EList functions in Lib.sol are thin wrappers around inco.* calls.