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

package/src/test/TestUpgrade.t.sol

@@ -3,7 +3,6 @@ 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), "");
     }