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

package/src/test/TestLib.t.sol

@@ -0,0 +1,794 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {IncoTest} from "./IncoTest.sol";
+import {e, euint256, ebool, eaddress, inco} from "../Lib.sol";
+import {ETypes} from "../Types.sol";
+
+/// @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 {
+
+    using e for euint256;
+    using e for ebool;
+    using e for uint256;
+    using e for bool;
+    using e for address;
+    using e for eaddress;
+    using e for bytes;
+
+    // ============ SANITIZE BRANCH TESTS ============
+
+    function testSanitizeEuint256Zero() public {
+        // Test sanitize with zero handle - should return asEuint256(0)
+        euint256 zero = euint256.wrap(bytes32(0));
+        euint256 sanitized = e.s(zero);
+        processAllOperations();
+        // After sanitize, a zero handle should become a valid encrypted 0
+        assertEq(getUint256Value(sanitized), 0);
+    }
+
+    function testSanitizeEboolZero() public {
+        // Test sanitize with zero handle - should return asEbool(false)
+        ebool zero = ebool.wrap(bytes32(0));
+        ebool sanitized = e.s(zero);
+        processAllOperations();
+        // After sanitize, a zero handle should become a valid encrypted false
+        assertEq(getBoolValue(sanitized), false);
+    }
+
+    function testSanitizeEaddress() public {
+        // Test sanitize(eaddress) with non-zero - just returns input
+        eaddress addr = e.asEaddress(address(0xdeadbeef));
+        processAllOperations();
+        eaddress sanitized = e.s(addr);
+        processAllOperations();
+        assertEq(getAddressValue(sanitized), address(0xdeadbeef));
+    }
+
+    function testSanitizeEaddressZero() public {
+        // Test sanitize with zero handle - should return asEaddress(0)
+        eaddress zero = eaddress.wrap(bytes32(0));
+        eaddress sanitized = e.s(zero);
+        processAllOperations();
+        // After sanitize, a zero handle should become a valid encrypted address(0)
+        assertEq(getAddressValue(sanitized), address(0));
+    }
+
+    // ============ SUB SCALAR VARIANTS ============
+
+    function testSubEuint256Uint256() public {
+        euint256 a = e.asEuint256(10);
+        euint256 c = a.sub(uint256(4));
+        processAllOperations();
+        assertEq(getUint256Value(c), 6);
+    }
+
+    function testSubUint256Euint256() public {
+        euint256 b = e.asEuint256(4);
+        euint256 c = uint256(10).sub(b);
+        processAllOperations();
+        assertEq(getUint256Value(c), 6);
+    }
+
+    // ============ MUL SCALAR VARIANTS ============
+
+    function testMulEuint256Uint256() public {
+        euint256 a = e.asEuint256(5);
+        euint256 c = a.mul(uint256(3));
+        processAllOperations();
+        assertEq(getUint256Value(c), 15);
+    }
+
+    function testMulUint256Euint256() public {
+        euint256 b = e.asEuint256(3);
+        euint256 c = uint256(5).mul(b);
+        processAllOperations();
+        assertEq(getUint256Value(c), 15);
+    }
+
+    // ============ DIV SCALAR VARIANTS ============
+
+    function testDivEuint256Uint256() public {
+        euint256 a = e.asEuint256(20);
+        euint256 c = a.div(uint256(4));
+        processAllOperations();
+        assertEq(getUint256Value(c), 5);
+    }
+
+    function testDivUint256Euint256() public {
+        euint256 b = e.asEuint256(4);
+        euint256 c = uint256(20).div(b);
+        processAllOperations();
+        assertEq(getUint256Value(c), 5);
+    }
+
+    // ============ REM SCALAR VARIANTS ============
+
+    function testRemEuint256Uint256() public {
+        euint256 a = e.asEuint256(10);
+        euint256 c = a.rem(uint256(3));
+        processAllOperations();
+        assertEq(getUint256Value(c), 1);
+    }
+
+    function testRemUint256Euint256() public {
+        euint256 b = e.asEuint256(3);
+        euint256 c = uint256(10).rem(b);
+        processAllOperations();
+        assertEq(getUint256Value(c), 1);
+    }
+
+    // ============ AND SCALAR/EBOOL VARIANTS ============
+
+    function testAndEuint256Uint256() public {
+        euint256 a = e.asEuint256(0xFF);
+        euint256 c = a.and(uint256(0x0F));
+        processAllOperations();
+        assertEq(getUint256Value(c), 0x0F);
+    }
+
+    function testAndUint256Euint256() public {
+        euint256 b = e.asEuint256(0x0F);
+        euint256 c = uint256(0xFF).and(b);
+        processAllOperations();
+        assertEq(getUint256Value(c), 0x0F);
+    }
+
+    function testAndEboolEbool() public {
+        ebool a = e.asEbool(true);
+        ebool b = e.asEbool(false);
+        ebool c = a.and(b);
+        processAllOperations();
+        assertEq(getBoolValue(c), false);
+    }
+
+    function testAndEboolBool() public {
+        ebool a = e.asEbool(true);
+        ebool c = a.and(false);
+        processAllOperations();
+        assertEq(getBoolValue(c), false);
+    }
+
+    function testAndBoolEbool() public {
+        ebool b = e.asEbool(true);
+        ebool c = true.and(b);
+        processAllOperations();
+        assertEq(getBoolValue(c), true);
+    }
+
+    // ============ OR SCALAR/EBOOL VARIANTS ============
+
+    function testOrEuint256Uint256() public {
+        euint256 a = e.asEuint256(0xF0);
+        euint256 c = a.or(uint256(0x0F));
+        processAllOperations();
+        assertEq(getUint256Value(c), 0xFF);
+    }
+
+    function testOrUint256Euint256() public {
+        euint256 b = e.asEuint256(0x0F);
+        euint256 c = uint256(0xF0).or(b);
+        processAllOperations();
+        assertEq(getUint256Value(c), 0xFF);
+    }
+
+    function testOrEboolEbool() public {
+        ebool a = e.asEbool(false);
+        ebool b = e.asEbool(true);
+        ebool c = a.or(b);
+        processAllOperations();
+        assertEq(getBoolValue(c), true);
+    }
+
+    function testOrEboolBool() public {
+        ebool a = e.asEbool(false);
+        ebool c = a.or(true);
+        processAllOperations();
+        assertEq(getBoolValue(c), true);
+    }
+
+    function testOrBoolEbool() public {
+        ebool b = e.asEbool(false);
+        ebool c = true.or(b);
+        processAllOperations();
+        assertEq(getBoolValue(c), true);
+    }
+
+    // ============ XOR SCALAR/EBOOL VARIANTS ============
+
+    function testXorEuint256Uint256() public {
+        euint256 a = e.asEuint256(0xFF);
+        euint256 c = a.xor(uint256(0x0F));
+        processAllOperations();
+        assertEq(getUint256Value(c), 0xF0);
+    }
+
+    function testXorUint256Euint256() public {
+        euint256 b = e.asEuint256(0x0F);
+        euint256 c = uint256(0xFF).xor(b);
+        processAllOperations();
+        assertEq(getUint256Value(c), 0xF0);
+    }
+
+    function testXorEboolEbool() public {
+        ebool a = e.asEbool(true);
+        ebool b = e.asEbool(true);
+        ebool c = a.xor(b);
+        processAllOperations();
+        assertEq(getBoolValue(c), false);
+    }
+
+    function testXorEboolBool() public {
+        ebool a = e.asEbool(true);
+        ebool c = a.xor(false);
+        processAllOperations();
+        assertEq(getBoolValue(c), true);
+    }
+
+    function testXorBoolEbool() public {
+        ebool b = e.asEbool(false);
+        ebool c = true.xor(b);
+        processAllOperations();
+        assertEq(getBoolValue(c), true);
+    }
+
+    // ============ SHL SCALAR VARIANTS ============
+
+    function testShlEuint256Uint256() public {
+        euint256 a = e.asEuint256(1);
+        euint256 c = a.shl(uint256(4));
+        processAllOperations();
+        assertEq(getUint256Value(c), 16);
+    }
+
+    function testShlUint256Euint256() public {
+        euint256 b = e.asEuint256(4);
+        euint256 c = uint256(1).shl(b);
+        processAllOperations();
+        assertEq(getUint256Value(c), 16);
+    }
+
+    // ============ SHR SCALAR VARIANTS ============
+
+    function testShrEuint256Uint256() public {
+        euint256 a = e.asEuint256(16);
+        euint256 c = a.shr(uint256(2));
+        processAllOperations();
+        assertEq(getUint256Value(c), 4);
+    }
+
+    function testShrUint256Euint256() public {
+        euint256 b = e.asEuint256(2);
+        euint256 c = uint256(16).shr(b);
+        processAllOperations();
+        assertEq(getUint256Value(c), 4);
+    }
+
+    // ============ ROTL SCALAR VARIANTS ============
+
+    function testRotlEuint256Uint256() public {
+        euint256 a = e.asEuint256(1);
+        euint256 c = a.rotl(uint256(4));
+        processAllOperations();
+        assertEq(getUint256Value(c), 16);
+    }
+
+    function testRotlUint256Euint256() public {
+        euint256 b = e.asEuint256(4);
+        euint256 c = uint256(1).rotl(b);
+        processAllOperations();
+        assertEq(getUint256Value(c), 16);
+    }
+
+    // ============ ROTR SCALAR VARIANTS ============
+
+    function testRotrEuint256Uint256() public {
+        euint256 a = e.asEuint256(16);
+        euint256 c = a.rotr(uint256(4));
+        processAllOperations();
+        assertEq(getUint256Value(c), 1);
+    }
+
+    function testRotrUint256Euint256() public {
+        euint256 b = e.asEuint256(4);
+        euint256 c = uint256(16).rotr(b);
+        processAllOperations();
+        assertEq(getUint256Value(c), 1);
+    }
+
+    // ============ EQ SCALAR/EADDRESS VARIANTS ============
+
+    function testEqEuint256Uint256() public {
+        euint256 a = e.asEuint256(10);
+        ebool c = a.eq(uint256(10));
+        processAllOperations();
+        assertEq(getBoolValue(c), true);
+    }
+
+    function testEqUint256Euint256() public {
+        euint256 b = e.asEuint256(10);
+        ebool c = uint256(10).eq(b);
+        processAllOperations();
+        assertEq(getBoolValue(c), true);
+    }
+
+    function testEqEaddressAddress() public {
+        eaddress a = e.asEaddress(alice);
+        processAllOperations();
+        ebool c = a.eq(alice);
+        processAllOperations();
+        assertEq(getBoolValue(c), true);
+    }
+
+    function testEqEaddressEaddress() public {
+        eaddress a = e.asEaddress(alice);
+        eaddress b = e.asEaddress(alice);
+        processAllOperations();
+        ebool c = a.eq(b);
+        processAllOperations();
+        assertEq(getBoolValue(c), true);
+    }
+
+    function testEqAddressEaddress() public {
+        eaddress b = e.asEaddress(alice);
+        processAllOperations();
+        ebool c = alice.eq(b);
+        processAllOperations();
+        assertEq(getBoolValue(c), true);
+    }
+
+    // ============ NE SCALAR/EADDRESS VARIANTS ============
+
+    function testNeEuint256Uint256() public {
+        euint256 a = e.asEuint256(10);
+        ebool c = a.ne(uint256(5));
+        processAllOperations();
+        assertEq(getBoolValue(c), true);
+    }
+
+    function testNeUint256Euint256() public {
+        euint256 b = e.asEuint256(5);
+        ebool c = uint256(10).ne(b);
+        processAllOperations();
+        assertEq(getBoolValue(c), true);
+    }
+
+    function testNeEaddressEaddress() public {
+        eaddress a = e.asEaddress(alice);
+        eaddress b = e.asEaddress(bob);
+        processAllOperations();
+        ebool c = a.ne(b);
+        processAllOperations();
+        assertEq(getBoolValue(c), true);
+    }
+
+    function testNeEaddressAddress() public {
+        eaddress a = e.asEaddress(alice);
+        processAllOperations();
+        ebool c = a.ne(bob);
+        processAllOperations();
+        assertEq(getBoolValue(c), true);
+    }
+
+    function testNeAddressEaddress() public {
+        eaddress b = e.asEaddress(bob);
+        processAllOperations();
+        ebool c = alice.ne(b);
+        processAllOperations();
+        assertEq(getBoolValue(c), true);
+    }
+
+    // ============ GE SCALAR VARIANTS ============
+
+    function testGeEuint256Uint256() public {
+        euint256 a = e.asEuint256(10);
+        ebool c = a.ge(uint256(10));
+        processAllOperations();
+        assertEq(getBoolValue(c), true);
+    }
+
+    function testGeUint256Euint256() public {
+        euint256 b = e.asEuint256(5);
+        ebool c = uint256(10).ge(b);
+        processAllOperations();
+        assertEq(getBoolValue(c), true);
+    }
+
+    // ============ GT SCALAR VARIANTS ============
+
+    function testGtEuint256Uint256() public {
+        euint256 a = e.asEuint256(10);
+        ebool c = a.gt(uint256(5));
+        processAllOperations();
+        assertEq(getBoolValue(c), true);
+    }
+
+    function testGtUint256Euint256() public {
+        euint256 b = e.asEuint256(5);
+        ebool c = uint256(10).gt(b);
+        processAllOperations();
+        assertEq(getBoolValue(c), true);
+    }
+
+    // ============ LE SCALAR VARIANTS ============
+
+    function testLeEuint256Uint256() public {
+        euint256 a = e.asEuint256(5);
+        ebool c = a.le(uint256(10));
+        processAllOperations();
+        assertEq(getBoolValue(c), true);
+    }
+
+    function testLeUint256Euint256() public {
+        euint256 b = e.asEuint256(10);
+        ebool c = uint256(5).le(b);
+        processAllOperations();
+        assertEq(getBoolValue(c), true);
+    }
+
+    // ============ LT SCALAR VARIANTS ============
+
+    function testLtEuint256Uint256() public {
+        euint256 a = e.asEuint256(5);
+        ebool c = a.lt(uint256(10));
+        processAllOperations();
+        assertEq(getBoolValue(c), true);
+    }
+
+    function testLtUint256Euint256() public {
+        euint256 b = e.asEuint256(10);
+        ebool c = uint256(5).lt(b);
+        processAllOperations();
+        assertEq(getBoolValue(c), true);
+    }
+
+    // ============ MIN SCALAR VARIANTS ============
+
+    function testMinEuint256Uint256() public {
+        euint256 a = e.asEuint256(10);
+        euint256 c = a.min(uint256(5));
+        processAllOperations();
+        assertEq(getUint256Value(c), 5);
+    }
+
+    function testMinUint256Euint256() public {
+        euint256 b = e.asEuint256(5);
+        euint256 c = uint256(10).min(b);
+        processAllOperations();
+        assertEq(getUint256Value(c), 5);
+    }
+
+    // ============ MAX SCALAR VARIANTS ============
+
+    function testMaxEuint256Uint256() public {
+        euint256 a = e.asEuint256(5);
+        euint256 c = a.max(uint256(10));
+        processAllOperations();
+        assertEq(getUint256Value(c), 10);
+    }
+
+    function testMaxUint256Euint256() public {
+        euint256 b = e.asEuint256(10);
+        euint256 c = uint256(5).max(b);
+        processAllOperations();
+        assertEq(getUint256Value(c), 10);
+    }
+
+    // ============ NEW ENCRYPTED TYPE (msg.sender variant) ============
+
+    function testNewEuint256MsgSender() public {
+        // Use a helper contract to test the msg.sender variant
+        LibTestHelper helper = new LibTestHelper();
+        vm.deal(address(helper), 1 ether);
+
+        bytes memory ciphertext = fakePrepareEuint256Ciphertext(42, address(helper), address(helper));
+        vm.prank(address(helper));
+        helper.callNewEuint256(ciphertext);
+        processAllOperations();
+
+        assertEq(getUint256Value(helper.storedEuint256()), 42);
+    }
+
+    function testNewEboolMsgSender() public {
+        LibTestHelper helper = new LibTestHelper();
+        vm.deal(address(helper), 1 ether);
+
+        bytes memory ciphertext = fakePrepareEboolCiphertext(true, address(helper), address(helper));
+        vm.prank(address(helper));
+        helper.callNewEbool(ciphertext);
+        processAllOperations();
+
+        assertEq(getBoolValue(helper.storedEbool()), true);
+    }
+
+    function testNewEaddressMsgSender() public {
+        LibTestHelper helper = new LibTestHelper();
+        vm.deal(address(helper), 1 ether);
+
+        bytes memory ciphertext = fakePrepareEaddressCiphertext(alice, address(helper), address(helper));
+        vm.prank(address(helper));
+        helper.callNewEaddress(ciphertext);
+        processAllOperations();
+
+        assertEq(getAddressValue(helper.storedEaddress()), alice);
+    }
+
+    // ============ ALLOW/REVEAL VARIANTS ============
+    // Note: When creating encrypted values (e.g., e.asEbool()), the caller (msg.sender)
+    // automatically receives TRANSIENT access via allowTransientInternal().
+    // isAllowed() returns true if transient OR persistent access is granted.
+    // The allow/allowThis functions grant PERSISTENT access (stored in contract storage).
+    // These tests verify persistent access by checking persistAllowed().
+
+    function testAllowEbool() public {
+        ebool a = e.asEbool(true);
+        processAllOperations();
+        // Creator has transient access but not persistent access
+        assertFalse(inco.persistAllowed(ebool.unwrap(a), alice));
+        e.allow(a, alice);
+        assertTrue(inco.persistAllowed(ebool.unwrap(a), alice));
+    }
+
+    function testAllowEaddress() public {
+        eaddress a = e.asEaddress(alice);
+        processAllOperations();
+        assertFalse(inco.persistAllowed(eaddress.unwrap(a), bob));
+        e.allow(a, bob);
+        assertTrue(inco.persistAllowed(eaddress.unwrap(a), bob));
+    }
+
+    function testRevealEuint256() public {
+        euint256 a = e.asEuint256(42);
+        processAllOperations();
+        assertFalse(inco.isRevealed(euint256.unwrap(a)));
+        e.reveal(a);
+        assertTrue(inco.isRevealed(euint256.unwrap(a)));
+    }
+
+    function testRevealEbool() public {
+        ebool a = e.asEbool(true);
+        processAllOperations();
+        assertFalse(inco.isRevealed(ebool.unwrap(a)));
+        e.reveal(a);
+        assertTrue(inco.isRevealed(ebool.unwrap(a)));
+    }
+
+    function testRevealEaddress() public {
+        eaddress a = e.asEaddress(alice);
+        processAllOperations();
+        assertFalse(inco.isRevealed(eaddress.unwrap(a)));
+        e.reveal(a);
+        assertTrue(inco.isRevealed(eaddress.unwrap(a)));
+    }
+
+    function testAllowThisEbool() public {
+        ebool a = e.asEbool(true);
+        processAllOperations();
+        // Creator has transient access but not persistent access yet
+        assertFalse(inco.persistAllowed(ebool.unwrap(a), address(this)));
+        e.allowThis(a);
+        assertTrue(inco.persistAllowed(ebool.unwrap(a), address(this)));
+    }
+
+    function testAllowThisEaddress() public {
+        eaddress a = e.asEaddress(alice);
+        processAllOperations();
+        // Creator has transient access but not persistent access yet
+        assertFalse(inco.persistAllowed(eaddress.unwrap(a), address(this)));
+        e.allowThis(a);
+        assertTrue(inco.persistAllowed(eaddress.unwrap(a), address(this)));
+    }
+
+    function testIsAllowed() public {
+        euint256 a = e.asEuint256(42);
+        processAllOperations();
+        e.allow(a, alice);
+        // isAllowed should return true for allowed address
+        bool allowed = e.isAllowed(alice, a);
+        assertTrue(allowed);
+    }
+
+    // ============ SELECT VARIANTS ============
+
+    function testSelectEboolEboolEbool() public {
+        ebool control = e.asEbool(true);
+        ebool ifTrue = e.asEbool(true);
+        ebool ifFalse = e.asEbool(false);
+        ebool result = control.select(ifTrue, ifFalse);
+        processAllOperations();
+        assertEq(getBoolValue(result), true);
+    }
+
+    function testSelectEboolEaddressEaddress() public {
+        ebool control = e.asEbool(false);
+        eaddress ifTrue = e.asEaddress(alice);
+        eaddress ifFalse = e.asEaddress(bob);
+        processAllOperations();
+        eaddress result = control.select(ifTrue, ifFalse);
+        processAllOperations();
+        assertEq(getAddressValue(result), bob);
+    }
+
+    // ============ SELECT WITH EUINT256 ============
+
+    function testSelectEboolEuint256Euint256() public {
+        ebool control = e.asEbool(true);
+        euint256 ifTrue = e.asEuint256(42);
+        euint256 ifFalse = e.asEuint256(100);
+        euint256 result = control.select(ifTrue, ifFalse);
+        processAllOperations();
+        assertEq(getUint256Value(result), 42);
+    }
+
+    function testSelectEboolEuint256Euint256False() public {
+        ebool control = e.asEbool(false);
+        euint256 ifTrue = e.asEuint256(42);
+        euint256 ifFalse = e.asEuint256(100);
+        euint256 result = control.select(ifTrue, ifFalse);
+        processAllOperations();
+        assertEq(getUint256Value(result), 100);
+    }
+
+    // ============ CAST OPERATIONS ============
+
+    function testCastEuint256ToEboolTrue() public {
+        euint256 a = e.asEuint256(1);
+        ebool b = e.asEbool(a);
+        processAllOperations();
+        assertEq(getBoolValue(b), true);
+    }
+
+    function testCastEuint256ToEboolFalse() public {
+        euint256 a = e.asEuint256(0);
+        ebool b = e.asEbool(a);
+        processAllOperations();
+        assertEq(getBoolValue(b), false);
+    }
+
+    function testCastEboolToEuint256True() public {
+        ebool a = e.asEbool(true);
+        euint256 b = e.asEuint256(a);
+        processAllOperations();
+        assertEq(getUint256Value(b), 1);
+    }
+
+    function testCastEboolToEuint256False() public {
+        ebool a = e.asEbool(false);
+        euint256 b = e.asEuint256(a);
+        processAllOperations();
+        assertEq(getUint256Value(b), 0);
+    }
+
+    // ============ EADDRESS CAST OPERATIONS (via inco.eCast directly) ============
+    // These test the underlying eCast functionality for eaddress conversions
+
+    function testCastEuint256ToEaddress() public {
+        euint256 a = e.asEuint256(uint256(uint160(alice)));
+        eaddress b = eaddress.wrap(inco.eCast(euint256.unwrap(a), ETypes.AddressOrUint160OrBytes20));
+        processAllOperations();
+        assertEq(getAddressValue(b), alice);
+    }
+
+    function testCastEuint256ToEaddressZero() public {
+        euint256 a = e.asEuint256(0);
+        eaddress b = eaddress.wrap(inco.eCast(euint256.unwrap(a), ETypes.AddressOrUint160OrBytes20));
+        processAllOperations();
+        assertEq(getAddressValue(b), address(0));
+    }
+
+    function testCastEboolToEaddressTrue() public {
+        ebool a = e.asEbool(true);
+        eaddress b = eaddress.wrap(inco.eCast(ebool.unwrap(a), ETypes.AddressOrUint160OrBytes20));
+        processAllOperations();
+        assertEq(getAddressValue(b), address(1));
+    }
+
+    function testCastEboolToEaddressFalse() public {
+        ebool a = e.asEbool(false);
+        eaddress b = eaddress.wrap(inco.eCast(ebool.unwrap(a), ETypes.AddressOrUint160OrBytes20));
+        processAllOperations();
+        assertEq(getAddressValue(b), address(0));
+    }
+
+    function testCastEaddressToEuint256() public {
+        eaddress a = e.asEaddress(alice);
+        processAllOperations();
+        euint256 b = euint256.wrap(inco.eCast(eaddress.unwrap(a), ETypes.Uint256));
+        processAllOperations();
+        assertEq(getUint256Value(b), uint256(uint160(alice)));
+    }
+
+    function testCastEaddressToEuint256Zero() public {
+        eaddress a = e.asEaddress(address(0));
+        processAllOperations();
+        euint256 b = euint256.wrap(inco.eCast(eaddress.unwrap(a), ETypes.Uint256));
+        processAllOperations();
+        assertEq(getUint256Value(b), 0);
+    }
+
+    function testCastEaddressToEboolNonZero() public {
+        eaddress a = e.asEaddress(alice);
+        processAllOperations();
+        ebool b = ebool.wrap(inco.eCast(eaddress.unwrap(a), ETypes.Bool));
+        processAllOperations();
+        assertEq(getBoolValue(b), true);
+    }
+
+    function testCastEaddressToEboolZero() public {
+        eaddress a = e.asEaddress(address(0));
+        processAllOperations();
+        ebool b = ebool.wrap(inco.eCast(eaddress.unwrap(a), ETypes.Bool));
+        processAllOperations();
+        assertEq(getBoolValue(b), false);
+    }
+
+    // ============ NOT OPERATION ============
+
+    function testNotEboolTrue() public {
+        ebool a = e.asEbool(true);
+        ebool b = a.not();
+        processAllOperations();
+        assertEq(getBoolValue(b), false);
+    }
+
+    function testNotEboolFalse() public {
+        ebool a = e.asEbool(false);
+        ebool b = a.not();
+        processAllOperations();
+        assertEq(getBoolValue(b), true);
+    }
+
+    // ============ RANDOM OPERATIONS ============
+
+    function testRand() public {
+        vm.deal(address(this), 1 ether);
+        euint256 r = e.rand();
+        processAllOperations();
+        // Just verify it returns a valid handle (non-zero after processing)
+        assertTrue(euint256.unwrap(r) != bytes32(0));
+    }
+
+    function testRandBoundedPlaintext() public {
+        vm.deal(address(this), 1 ether);
+        euint256 r = e.randBounded(uint256(100));
+        processAllOperations();
+        // Verify result is less than bound
+        uint256 value = getUint256Value(r);
+        assertTrue(value < 100);
+    }
+
+    function testRandBoundedEncrypted() public {
+        vm.deal(address(this), 1 ether);
+        euint256 bound = e.asEuint256(50);
+        euint256 r = e.randBounded(bound);
+        processAllOperations();
+        // Verify result is less than bound
+        uint256 value = getUint256Value(r);
+        assertTrue(value < 50);
+    }
+
+}
+
+/// @notice Helper contract for testing msg.sender variants
+contract LibTestHelper {
+
+    using e for bytes;
+
+    euint256 public storedEuint256;
+    ebool public storedEbool;
+    eaddress public storedEaddress;
+
+    function callNewEuint256(bytes memory ciphertext) external {
+        storedEuint256 = ciphertext.newEuint256();
+    }
+
+    function callNewEbool(bytes memory ciphertext) external {
+        storedEbool = ciphertext.newEbool();
+    }
+
+    function callNewEaddress(bytes memory ciphertext) external {
+        storedEaddress = ciphertext.newEaddress();
+    }
+
+}