@inco/lightning 0.9.0-devnet-test-4 → 0.10.0-devnet-1

package/src/test/TestReceive.t.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {inco} from "../Lib.sol";
+import {IncoTest} from "./IncoTest.sol";
+import {IIncoLightning} from "../interfaces/IIncoLightning.sol";
+
+contract TestReceive is IncoTest {
+
+    function setUp() public override {
+        super.setUp();
+    }
+
+    function testReceive_Reverts() public {
+        uint256 sendAmount = 1 ether;
+        vm.deal(alice, sendAmount);
+        vm.prank(alice);
+        (bool success, bytes memory returnData) = address(inco).call{value: sendAmount}("");
+
+        assertFalse(success, "ETH transfer should revert");
+        bytes4 expectedSelector = IIncoLightning.EthInboundTransferUnsupported.selector;
+        bytes4 actualSelector;
+        assembly {
+            actualSelector := mload(add(returnData, 32))
+        }
+        assertEq(actualSelector, expectedSelector, "Should revert with EthInboundTransferUnsupported");
+    }
+
+    function testReceive_ZeroValue_Reverts() public {
+        vm.prank(alice);
+        (bool success, bytes memory returnData) = address(inco).call{value: 0}("");
+
+        assertFalse(success, "Zero value transfer should also revert");
+        bytes4 expectedSelector = IIncoLightning.EthInboundTransferUnsupported.selector;
+        bytes4 actualSelector;
+        assembly {
+            actualSelector := mload(add(returnData, 32))
+        }
+        assertEq(actualSelector, expectedSelector, "Should revert with EthInboundTransferUnsupported");
+    }
+
+}

package/src/test/TestUpgrade.t.sol

@@ -1,9 +1,8 @@
 // SPDX-License-Identifier: No License
-pragma solidity ^0.8.20;
+pragma solidity ^0.8;
 
 import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
 import {Safe} from "safe-smart-account/Safe.sol";
-import {SafeProxyFactory} from "safe-smart-account/proxies/SafeProxyFactory.sol";
 import {Enum} from "safe-smart-account/libraries/Enum.sol";
 import {IOwnerManager} from "safe-smart-account/interfaces/IOwnerManager.sol";
 import {IncoTest} from "./IncoTest.sol";
@@ -49,36 +48,14 @@ contract TestUpgrade is IncoTest {
     IncoLightning private v1Impl;
     IncoLightningV2 private v2Impl;
 
-    Safe private safe;
+    function safe() internal view returns (Safe) {
+        return Safe(payable(owner));
+    }
 
     function setUp() public override {
         super.setUp();
         incoProxyAddr = address(inco);
 
-        Safe master = new Safe();
-        SafeProxyFactory factory = new SafeProxyFactory();
-
-        address[] memory owners = new address[](3);
-        owners[0] = alice;
-        owners[1] = bob;
-        owners[2] = carol;
-        uint256 threshold = 2;
-        bytes memory setupData = abi.encodeWithSelector(
-            Safe.setup.selector,
-            owners,
-            threshold,
-            address(0),
-            bytes(""),
-            address(0),
-            address(0),
-            0,
-            payable(address(0))
-        );
-        safe = Safe(payable(factory.createProxyWithNonce(address(master), setupData, 0)));
-
-        vm.prank(owner);
-        inco.transferOwnership(address(safe));
-
         // Deploy V2
         bytes32 salt = getSalt("IncoLightningV2", 255, testDeployer, "testnet");
         v2Impl = new IncoLightningV2(salt);
@@ -99,14 +76,14 @@ contract TestUpgrade is IncoTest {
         // data to sign
         bytes memory data = abi.encodeWithSelector(IUUPS.upgradeToAndCall.selector, address(v2Impl), "");
         // prepare txhash
-        bytes32 txHash = _txHash(safe, incoProxyAddr, 0, data);
+        bytes32 txHash = _txHash(safe(), incoProxyAddr, 0, data);
         // sign txHash
         bytes memory sigA = _sign(alicePrivKey, txHash);
         bytes memory sigB = _sign(bobPrivKey, txHash);
         // sort signatures (asc)
         bytes memory signatures = _packSortedTwo(sigA, alice, sigB, bob);
         // execute tx with sorted signatures
-        _execSafe(safe, incoProxyAddr, 0, data, signatures);
+        _execSafe(safe(), incoProxyAddr, 0, data, signatures);
 
         address implAfter = address(uint160(uint256(vm.load(incoProxyAddr, IMPLEMENTATION_SLOT))));
         assertEq(implAfter, address(v2Impl));
@@ -117,75 +94,75 @@ contract TestUpgrade is IncoTest {
 
     function test_SafeSingleSignature_Fails() public {
         bytes memory data = abi.encodeWithSelector(IUUPS.upgradeToAndCall.selector, address(v2Impl), "");
-        bytes32 txHash = _txHash(safe, incoProxyAddr, 0, data);
+        bytes32 txHash = _txHash(safe(), incoProxyAddr, 0, data);
         bytes memory sigA = _sign(alicePrivKey, txHash);
         vm.expectRevert();
-        _execSafe(safe, incoProxyAddr, 0, data, sigA);
+        _execSafe(safe(), incoProxyAddr, 0, data, sigA);
     }
 
     function test_Safe_UnsortedSignatures_Fails() public {
         bytes memory data = abi.encodeWithSelector(IUUPS.upgradeToAndCall.selector, address(v2Impl), "");
-        bytes32 txHash = _txHash(safe, incoProxyAddr, 0, data);
+        bytes32 txHash = _txHash(safe(), incoProxyAddr, 0, data);
         bytes memory sigA = _sign(alicePrivKey, txHash);
         bytes memory sigC = _sign(carolPrivKey, txHash);
         bytes memory signatures = bytes.concat(sigC, sigA); // unsorted
         vm.expectRevert();
-        _execSafe(safe, incoProxyAddr, 0, data, signatures);
+        _execSafe(safe(), incoProxyAddr, 0, data, signatures);
     }
 
     function test_Safe_WrongSigner_Fails() public {
         bytes memory data = abi.encodeWithSelector(IUUPS.upgradeToAndCall.selector, address(v2Impl), "");
-        bytes32 txHash = _txHash(safe, incoProxyAddr, 0, data);
+        bytes32 txHash = _txHash(safe(), incoProxyAddr, 0, data);
         bytes memory sigOwner = _sign(alicePrivKey, txHash);
         bytes memory sigAttacker = _sign(davePrivKey, txHash);
         bytes memory signatures = _packSortedTwo(sigOwner, alice, sigAttacker, dave); // dave not an owner
         vm.expectRevert();
-        _execSafe(safe, incoProxyAddr, 0, data, signatures);
+        _execSafe(safe(), incoProxyAddr, 0, data, signatures);
     }
 
     function test_Safe_ReplayNonce_Fails() public {
         bytes memory data = abi.encodeWithSelector(IUUPS.upgradeToAndCall.selector, address(v2Impl), "");
-        bytes32 txHash = _txHash(safe, incoProxyAddr, 0, data);
+        bytes32 txHash = _txHash(safe(), incoProxyAddr, 0, data);
         bytes memory sigA = _sign(alicePrivKey, txHash);
         bytes memory sigB = _sign(bobPrivKey, txHash);
         bytes memory signatures = _packSortedTwo(sigA, alice, sigB, bob);
-        _execSafe(safe, incoProxyAddr, 0, data, signatures);
+        _execSafe(safe(), incoProxyAddr, 0, data, signatures);
 
         string memory versionAfter = inco.getVersion();
         assertEq(versionAfter, "255_255_255");
 
         vm.expectRevert();
-        _execSafe(safe, incoProxyAddr, 0, data, signatures); // nonce advanced
+        _execSafe(safe(), incoProxyAddr, 0, data, signatures); // nonce advanced
     }
 
     function test_Safe_UpdateSigners_SwapOwner_ThenUpgrade() public {
         // swap bob -> eve (prevOwner = alice since owners were [alice, bob, carol])
         bytes memory change = abi.encodeWithSelector(IOwnerManager.swapOwner.selector, alice, bob, eve);
-        bytes32 changeHash = _txHash(safe, address(safe), 0, change);
+        bytes32 changeHash = _txHash(safe(), address(safe()), 0, change);
         bytes memory changeSigA = _sign(alicePrivKey, changeHash);
         bytes memory changeSigC = _sign(carolPrivKey, changeHash);
         bytes memory changeSigs = _packSortedTwo(changeSigA, alice, changeSigC, carol);
-        _execSafe(safe, address(safe), 0, change, changeSigs);
+        _execSafe(safe(), address(safe()), 0, change, changeSigs);
 
         // assertions on owners/threshold
-        assertTrue(safe.isOwner(eve), "new owner not added");
-        assertFalse(safe.isOwner(bob), "old owner not removed");
-        assertEq(safe.getThreshold(), 2, "threshold changed unexpectedly");
+        assertTrue(safe().isOwner(eve), "new owner not added");
+        assertFalse(safe().isOwner(bob), "old owner not removed");
+        assertEq(safe().getThreshold(), 2, "threshold changed unexpectedly");
 
         // Attempt upgrade signed by removed owner should fail
         bytes memory upg = abi.encodeWithSelector(IUUPS.upgradeToAndCall.selector, address(v2Impl), "");
-        bytes32 upgHash = _txHash(safe, incoProxyAddr, 0, upg);
+        bytes32 upgHash = _txHash(safe(), incoProxyAddr, 0, upg);
         bytes memory badSigA = _sign(alicePrivKey, upgHash);
         bytes memory badSigB = _sign(bobPrivKey, upgHash); // removed owner
         bytes memory badSigs = _packSortedTwo(badSigA, alice, badSigB, bob);
         vm.expectRevert();
-        _execSafe(safe, incoProxyAddr, 0, upg, badSigs);
+        _execSafe(safe(), incoProxyAddr, 0, upg, badSigs);
 
         // Now sign with new owner (owner4) and succeed
         bytes memory goodSigA = _sign(alicePrivKey, upgHash);
         bytes memory goodSigE = _sign(evePrivKey, upgHash);
         bytes memory goodSigs = _packSortedTwo(goodSigA, alice, goodSigE, eve);
-        _execSafe(safe, incoProxyAddr, 0, upg, goodSigs);
+        _execSafe(safe(), incoProxyAddr, 0, upg, goodSigs);
 
         address implAfter = address(uint160(uint256(vm.load(incoProxyAddr, IMPLEMENTATION_SLOT))));
         assertEq(implAfter, address(v2Impl));
@@ -195,7 +172,7 @@ contract TestUpgrade is IncoTest {
     }
 
     function test_Upgrade_NotBy_SafeWallet_Fails() public {
-        vm.prank(owner);
+        vm.prank(alice);
         vm.expectRevert();
         inco.upgradeToAndCall(address(v2Impl), "");
     }
@@ -222,7 +199,7 @@ contract TestUpgrade is IncoTest {
         // Deploy a new IncoVerifier implementation
         IncoVerifier newImpl = new IncoVerifier(address(inco));
 
-        // Upgrade by owner should succeed
+        // Upgrade by owner should succeed — owner is the Safe, so prank as Safe
         vm.prank(owner);
         verifier.upgradeToAndCall(address(newImpl), "");
     }
@@ -271,20 +248,12 @@ contract TestUpgrade is IncoTest {
     }
 
     function test_SessionVerifier_Initialize() public {
-        SessionVerifier impl = new SessionVerifier("");
-        ERC1967Proxy proxy = new ERC1967Proxy(address(impl), "");
-        SessionVerifier verifier = SessionVerifier(address(proxy));
-
-        verifier.initialize(alice);
+        SessionVerifier verifier = _deploySessionVerifierProxy(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);
+        SessionVerifier verifier = _deploySessionVerifierProxy(alice);
 
         // Deploy new implementation
         SessionVerifier newImpl = new SessionVerifier("");
@@ -295,11 +264,7 @@ contract TestUpgrade is IncoTest {
     }
 
     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);
+        SessionVerifier verifier = _deploySessionVerifierProxy(alice);
 
         // Deploy new implementation
         SessionVerifier newImpl = new SessionVerifier("");
@@ -311,6 +276,12 @@ contract TestUpgrade is IncoTest {
     }
 
     // Helpers
+    function _deploySessionVerifierProxy(address proxyOwner) private returns (SessionVerifier) {
+        SessionVerifier impl = new SessionVerifier("");
+        ERC1967Proxy proxy = new ERC1967Proxy(address(impl), abi.encodeCall(SessionVerifier.initialize, (proxyOwner)));
+        return SessionVerifier(address(proxy));
+    }
+
     function _txHash(Safe _safe, address to, uint256 value, bytes memory data) internal view returns (bytes32) {
         return _safe.getTransactionHash(
             to, value, data, Enum.Operation.Call, 0, 0, 0, address(0), payable(address(0)), _safe.nonce()

package/src/version/IncoLightningConfig.sol

@@ -7,7 +7,7 @@ pragma solidity ^0.8;
 // UPDATE the CHANGELOG on new versions
 
 string constant CONTRACT_NAME = "incoLightning";
-uint8 constant MAJOR_VERSION = 4;
+uint8 constant MAJOR_VERSION = 10;
 uint8 constant MINOR_VERSION = 0;
 // whenever a new version is deployed, we need to pump this up
 // otherwise make test_upgrade will fail