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

package/src/test/TestUpgrade.t.sol

@@ -9,6 +9,10 @@ import {IOwnerManager} from "safe-smart-account/interfaces/IOwnerManager.sol";
 import {IncoTest} from "./IncoTest.sol";
 import {inco} from "../Lib.sol";
 import {IncoLightning} from "../IncoLightning.sol";
+import {IncoVerifier} from "../IncoVerifier.sol";
+import {SessionVerifier, Session} from "../periphery/SessionVerifier.sol";
+import {ALLOWANCE_GRANTED_MAGIC_VALUE} from "../Types.sol";
+import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
 import {IVersion} from "../version/interfaces/IVersion.sol";
 import {Version} from "../version/Version.sol";
 import {IIncoVerifier} from "../interfaces/IIncoVerifier.sol";
@@ -196,6 +200,116 @@ contract TestUpgrade is IncoTest {
         inco.upgradeToAndCall(address(v2Impl), "");
     }
 
+    // ============ IncoVerifier Tests ============
+
+    function test_IncoVerifier_GetEIP712Name() public view {
+        IncoVerifier verifier = IncoVerifier(address(inco.incoVerifier()));
+        string memory name = verifier.getEIP712Name();
+        // Name should not be empty
+        assertGt(bytes(name).length, 0, "EIP712 name should not be empty");
+    }
+
+    function test_IncoVerifier_GetEIP712Version() public view {
+        IncoVerifier verifier = IncoVerifier(address(inco.incoVerifier()));
+        string memory version = verifier.getEIP712Version();
+        // Version should not be empty
+        assertGt(bytes(version).length, 0, "EIP712 version should not be empty");
+    }
+
+    function test_IncoVerifier_Upgrade_ByOwner_Succeeds() public {
+        IncoVerifier verifier = IncoVerifier(address(inco.incoVerifier()));
+
+        // Deploy a new IncoVerifier implementation
+        IncoVerifier newImpl = new IncoVerifier(address(inco));
+
+        // Upgrade by owner should succeed
+        vm.prank(owner);
+        verifier.upgradeToAndCall(address(newImpl), "");
+    }
+
+    function test_IncoVerifier_Upgrade_ByNonOwner_Fails() public {
+        IncoVerifier verifier = IncoVerifier(address(inco.incoVerifier()));
+
+        // Deploy a new IncoVerifier implementation
+        IncoVerifier newImpl = new IncoVerifier(address(inco));
+
+        // Upgrade by non-owner should fail
+        vm.prank(alice);
+        vm.expectRevert();
+        verifier.upgradeToAndCall(address(newImpl), "");
+    }
+
+    // ============ SessionVerifier Tests ============
+
+    function test_SessionVerifier_ValidSession_ReturnsAllowanceGranted() public {
+        SessionVerifier verifier = new SessionVerifier("");
+
+        bytes memory sharerArgData = abi.encode(Session({decrypter: bob, expiresAt: block.timestamp + 1 days}));
+
+        bytes32 result = verifier.canUseSession(bytes32(0), bob, sharerArgData, "");
+        assertEq(result, ALLOWANCE_GRANTED_MAGIC_VALUE, "Valid session should return ALLOWANCE_GRANTED_MAGIC_VALUE");
+    }
+
+    function test_SessionVerifier_ExpiredSession_ReturnsZero() public {
+        SessionVerifier verifier = new SessionVerifier("");
+
+        // Create session that expired 1 second ago
+        bytes memory sharerArgData = abi.encode(Session({decrypter: bob, expiresAt: block.timestamp - 1}));
+
+        bytes32 result = verifier.canUseSession(bytes32(0), bob, sharerArgData, "");
+        assertEq(result, bytes32(0), "Expired session should return bytes32(0)");
+    }
+
+    function test_SessionVerifier_WrongDecrypter_ReturnsZero() public {
+        SessionVerifier verifier = new SessionVerifier("");
+
+        // Session is valid but decrypter doesn't match caller
+        bytes memory sharerArgData = abi.encode(Session({decrypter: alice, expiresAt: block.timestamp + 1 days}));
+
+        bytes32 result = verifier.canUseSession(bytes32(0), bob, sharerArgData, "");
+        assertEq(result, bytes32(0), "Wrong decrypter should return bytes32(0)");
+    }
+
+    function test_SessionVerifier_Initialize() public {
+        SessionVerifier impl = new SessionVerifier("");
+        ERC1967Proxy proxy = new ERC1967Proxy(address(impl), "");
+        SessionVerifier verifier = SessionVerifier(address(proxy));
+
+        verifier.initialize(alice);
+        assertEq(verifier.owner(), alice, "Owner should be alice after initialize");
+    }
+
+    function test_SessionVerifier_Upgrade_ByOwner_Succeeds() public {
+        SessionVerifier impl = new SessionVerifier("");
+        ERC1967Proxy proxy = new ERC1967Proxy(address(impl), "");
+        SessionVerifier verifier = SessionVerifier(address(proxy));
+
+        verifier.initialize(alice);
+
+        // Deploy new implementation
+        SessionVerifier newImpl = new SessionVerifier("");
+
+        // Upgrade by owner should succeed
+        vm.prank(alice);
+        verifier.upgradeToAndCall(address(newImpl), "");
+    }
+
+    function test_SessionVerifier_Upgrade_ByNonOwner_Fails() public {
+        SessionVerifier impl = new SessionVerifier("");
+        ERC1967Proxy proxy = new ERC1967Proxy(address(impl), "");
+        SessionVerifier verifier = SessionVerifier(address(proxy));
+
+        verifier.initialize(alice);
+
+        // Deploy new implementation
+        SessionVerifier newImpl = new SessionVerifier("");
+
+        // Upgrade by non-owner should fail
+        vm.prank(bob);
+        vm.expectRevert();
+        verifier.upgradeToAndCall(address(newImpl), "");
+    }
+
     // Helpers
     function _txHash(Safe _safe, address to, uint256 value, bytes memory data) internal view returns (bytes32) {
         return _safe.getTransactionHash(

package/src/test/TestVersion.t.sol

@@ -25,6 +25,7 @@ contract TestVersion is Test {
         assertEq(someContract.getName(), "SomeContract");
         assertEq(someContract.getVersion(), "1_2_3");
         assertEq(someContract.getVersionedName(), "SomeContract_1_2_3__12345678");
+        assertEq(someContract.salt(), bytes32(uint256(12345678)));
     }
 
 }

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))));
-    }
-
-}