test: invariant basic properties

test/invariant/fuzz/Setup.t.sol

@@ -39,24 +39,13 @@ contract Setup is Actors {
         registry = new Registry();
 
         // Deploy the proxy, pointing to the implementation
-        TransparentUpgradeableProxy proxy = new TransparentUpgradeableProxy(
-            implementation,
-            proxyOwner,
-            ""
-        );
+        TransparentUpgradeableProxy proxy = new TransparentUpgradeableProxy(implementation, proxyOwner, "");
 
         allo = Allo(payable(address(proxy)));
 
         // Initialize
         vm.prank(protocolDeployer);
-        allo.initialize(
-            protocolDeployer,
-            address(registry),
-            payable(treasury),
-            percentFee,
-            baseFee,
-            forwarder
-        );
+        allo.initialize(protocolDeployer, address(registry), payable(treasury), percentFee, baseFee, forwarder);
 
         // Deploy base strategy
         strategy_directAllocation = new DirectAllocationStrategy(address(allo));
@@ -65,20 +54,12 @@ contract Setup is Actors {
         token = ERC20(address(new FuzzERC20()));
 
         // Create profile for 4 addresses
-        for (uint i; i < 4; i++) {
+        for (uint256 i; i < 4; i++) {
             bytes32 _id = registry.createProfile(
-                0,
-                "a",
-                Metadata({protocol: i + 1, pointer: ""}),
-                _ghost_actors[i],
-                new address[](0)
+                0, "a", Metadata({protocol: i + 1, pointer: ""}), _ghost_actors[i], new address[](0)
             );
 
-            _addAnchorToActor(
-                _ghost_actors[i],
-                registry.getProfileById(_id).anchor,
-                _id
-            );
+            _addAnchorToActor(_ghost_actors[i], registry.getProfileById(_id).anchor, _id);
         }
     }
 }

test/invariant/fuzz/handlers/HandlerAllo.t.sol

@@ -14,9 +14,7 @@ contract HandlerAllo is Setup {
 
     function handler_createPool(uint256 _msgValue) public {
         // Get the profile ID
-        IRegistry.Profile memory profile = registry.getProfileByAnchor(
-            _ghost_anchorOf[msg.sender]
-        );
+        IRegistry.Profile memory profile = registry.getProfileByAnchor(_ghost_anchorOf[msg.sender]);
 
         // Avoid EOA
         if (profile.anchor == address(0)) return;
@@ -46,11 +44,7 @@ contract HandlerAllo is Setup {
         }
     }
 
-    function handler_updatePoolMetadata(
-        uint256 _idSeed,
-        uint256 _metadataProtocol,
-        string calldata _data
-    ) public {
+    function handler_updatePoolMetadata(uint256 _idSeed, uint256 _metadataProtocol, string calldata _data) public {
         // Needs at least one pool
         if (ghost_poolIds.length == 0) return;
 
@@ -59,91 +53,56 @@ contract HandlerAllo is Setup {
         uint256 poolId = ghost_poolIds[_idSeed];
 
         // Get the profile ID
-        IRegistry.Profile memory profile = registry.getProfileByAnchor(
-            _ghost_anchorOf[msg.sender]
-        );
+        IRegistry.Profile memory profile = registry.getProfileByAnchor(_ghost_anchorOf[msg.sender]);
 
         // Avoid EOA
         if (profile.anchor == address(0)) return;
 
-        Metadata memory metadata = Metadata({
-            protocol: _metadataProtocol,
-            pointer: _data
-        });
+        Metadata memory metadata = Metadata({protocol: _metadataProtocol, pointer: _data});
 
         // Update the pool metadata - will revert on wrong anchor
-        targetCall(
-            address(allo),
-            0,
-            abi.encodeCall(allo.updatePoolMetadata, (poolId, metadata))
-        );
+        targetCall(address(allo), 0, abi.encodeCall(allo.updatePoolMetadata, (poolId, metadata)));
     }
 
     function handler_updatePercentFee(uint256 _newPercentFee) public {
         _newPercentFee = bound(_newPercentFee, 0, 1e18);
 
         // Update the percent fee - will revert if caller is not the owner
-        targetCall(
-            address(allo),
-            0,
-            abi.encodeCall(allo.updatePercentFee, (_newPercentFee))
-        );
+        targetCall(address(allo), 0, abi.encodeCall(allo.updatePercentFee, (_newPercentFee)));
     }
 
     function handler_updateBaseFee(uint256 _newBaseFee) public {
         // Update the base fee - will revert if caller is not the owner
-        targetCall(
-            address(allo),
-            0,
-            abi.encodeCall(allo.updateBaseFee, (_newBaseFee))
-        );
+        targetCall(address(allo), 0, abi.encodeCall(allo.updateBaseFee, (_newBaseFee)));
     }
 
     function handler_updateRegistry(address _newRegistry) public {
         // Update the registry - will revert if caller is not the owner or if the new registry is zero
-        targetCall(
-            address(allo),
-            0,
-            abi.encodeCall(allo.updateRegistry, (_newRegistry))
-        );
+        targetCall(address(allo), 0, abi.encodeCall(allo.updateRegistry, (_newRegistry)));
     }
 
     function handler_updateTreasury(address _newTreasury) public {
         // Update the treasury - will revert if caller is not the owner or if the new treasury is zero
-        targetCall(
-            address(allo),
-            0,
-            abi.encodeCall(allo.updateTreasury, (payable(_newTreasury)))
-        );
+        targetCall(address(allo), 0, abi.encodeCall(allo.updateTreasury, (payable(_newTreasury))));
     }
 
     function handler_updateTrustedForwarder(address _newForwarder) public {
         // Update the trusted forwarder - will revert if caller is not the owner or if the new forwarder is zero
-        targetCall(
-            address(allo),
-            0,
-            abi.encodeCall(Allo.updateTrustedForwarder, (_newForwarder))
-        );
+        targetCall(address(allo), 0, abi.encodeCall(Allo.updateTrustedForwarder, (_newForwarder)));
     }
 
-    function handler_addPoolManagers(
-        uint256 _idSeed,
-        uint256 _numberOfManagers
-    ) public {
+    function handler_addPoolManagers(uint256 _idSeed, uint256 _numberOfManagers) public {
         uint256 _poolId = _pickPoolId(_idSeed);
         _numberOfManagers = bound(_numberOfManagers, 0, _ghost_actors.length);
 
         // Gather the managers
         address[] memory _managers = new address[](_numberOfManagers);
-        for (uint256 i; i < _numberOfManagers; i++)
+        for (uint256 i; i < _numberOfManagers; i++) {
             _managers[i] = _ghost_actors[i];
+        }
 
         // Add pool managers - will revert if caller is not the pool admin of the pool id
-        (bool _succ, ) = targetCall(
-            address(allo),
-            0,
-            abi.encodeCall(allo.addPoolManagers, (_poolId, _managers))
-        );
+        (bool _succ,) = targetCall(address(allo), 0, abi.encodeCall(allo.addPoolManagers, (_poolId, _managers)));
 
         if (_succ) {
             for (uint256 _i; _i < _managers.length; ++_i) {
@@ -157,11 +116,7 @@ contract HandlerAllo is Setup {
         address[] memory _managers = ghost_poolManagers[_poolId];
 
         // Remove pool managers - will revert if caller is not a pool admin of the pool id
-        (bool _succ, ) = targetCall(
-            address(allo),
-            0,
-            abi.encodeCall(allo.removePoolManagers, (_poolId, _managers))
-        );
+        (bool _succ,) = targetCall(address(allo), 0, abi.encodeCall(allo.removePoolManagers, (_poolId, _managers)));
 
         if (_succ) {
             delete ghost_poolManagers[_poolId];
@@ -170,11 +125,7 @@ contract HandlerAllo is Setup {
 
     function handler_recoverFunds(address _recipient) public {
         // Recover funds - will revert if caller is not the owner
-        targetCall(
-            address(allo),
-            0,
-            abi.encodeCall(allo.recoverFunds, (address(token), _recipient))
-        );
+        targetCall(address(allo), 0, abi.encodeCall(allo.recoverFunds, (address(token), _recipient)));
     }
 
     function handler_registerRecipient(
@@ -184,40 +135,28 @@ contract HandlerAllo is Setup {
         uint256 _msgValue
     ) public {
         uint256 _poolId = _pickPoolId(_idSeed);
-        _numberOfRecipients = bound(
-            _numberOfRecipients,
-            0,
-            _ghost_actors.length
-        );
+        _numberOfRecipients = bound(_numberOfRecipients, 0, _ghost_actors.length);
 
         // Gather the recipients
-        address[] memory _recipientAddresses = new address[](
-            _numberOfRecipients
-        );
-        for (uint256 i; i < _numberOfRecipients; i++)
+        address[] memory _recipientAddresses = new address[](_numberOfRecipients);
+        for (uint256 i; i < _numberOfRecipients; i++) {
             _recipientAddresses[i] = _ghost_actors[i];
+        }
 
         // Register recipient
-        (bool succ, ) = targetCall(
-            address(allo),
-            _msgValue,
-            abi.encodeCall(
-                allo.registerRecipient,
-                (_poolId, _recipientAddresses, _data)
-            )
+        (bool succ,) = targetCall(
+            address(allo), _msgValue, abi.encodeCall(allo.registerRecipient, (_poolId, _recipientAddresses, _data))
         );
 
         // todo: double-check there is no way a recipient is registered twice
-        if (succ)
-            for (uint256 i; i < _recipientAddresses.length; i++)
+        if (succ) {
+            for (uint256 i; i < _recipientAddresses.length; i++) {
                 ghost_recipients[_poolId].push(_recipientAddresses[i]);
+            }
+        }
     }
 
-    function handler_fundPool(
-        uint256 _idSeed,
-        uint256 _amount,
-        uint256 _msgValue
-    ) public {
+    function handler_fundPool(uint256 _idSeed, uint256 _amount, uint256 _msgValue) public {
         uint256 _poolId = _pickPoolId(_idSeed);
         uint256 _previousBalance = token.balanceOf(address(msg.sender));
 
@@ -230,20 +169,13 @@ contract HandlerAllo is Setup {
         }
 
         // Fund pool - will revert if the amount is zero or if pool token is native and message value is != amount
-        targetCall(
-            address(allo),
-            _msgValue,
-            abi.encodeCall(allo.fundPool, (_poolId, _amount))
-        );
+        targetCall(address(allo), _msgValue, abi.encodeCall(allo.fundPool, (_poolId, _amount)));
     }
 
     // _seedAmounts at 50 as it is not likely we'll handle 50 actors at the same time (update if so)
-    function handler_allocate(
-        uint256 _idSeed,
-        uint256[50] memory _seedAmounts,
-        bytes memory _data,
-        uint256 _msgValue
-    ) public {
+    function handler_allocate(uint256 _idSeed, uint256[50] memory _seedAmounts, bytes memory _data, uint256 _msgValue)
+        public
+    {
         uint256 _poolId = _pickPoolId(_idSeed);
 
         address[] memory _recipients = ghost_recipients[_poolId];
@@ -254,52 +186,27 @@ contract HandlerAllo is Setup {
             _amounts[i] = _seedAmounts[i];
 
             if (_amounts[i] > 0) {
-                FuzzERC20(address(token)).mint(
-                    address(msg.sender),
-                    _amounts[i]
-                );
+                FuzzERC20(address(token)).mint(address(msg.sender), _amounts[i]);
             }
         }
 
         // Allocate - allocate to a recipient or multiple recipients
-        targetCall(
-            address(allo),
-            _msgValue,
-            abi.encodeCall(
-                allo.allocate,
-                (_poolId, _recipients, _amounts, _data)
-            )
-        );
+        targetCall(address(allo), _msgValue, abi.encodeCall(allo.allocate, (_poolId, _recipients, _amounts, _data)));
     }
 
-    function handler_distribute(
-        uint256 _idSeed,
-        address[] memory _recipientIds,
-        bytes memory _data
-    ) public {
+    function handler_distribute(uint256 _idSeed, address[] memory _recipientIds, bytes memory _data) public {
         uint256 _poolId = _pickPoolId(_idSeed);
 
         // Distribute - distribute to a recipient or multiple recipients
-        targetCall(
-            address(allo),
-            0,
-            abi.encodeCall(
-                allo.distribute,
-                (_poolId, ghost_recipients[_idSeed], _data)
-            )
-        );
+        targetCall(address(allo), 0, abi.encodeCall(allo.distribute, (_poolId, ghost_recipients[_idSeed], _data)));
     }
 
     function handler_changeAdmin(uint256 _seed, uint256 _seedAdmin) public {
         uint256 _poolId = _pickPoolId(_seed);
         address _newAdmin = _ghost_actors[_seedAdmin % _ghost_actors.length];
 
         // Change admin - will revert if caller is not the pool admin
-        (bool success,) = targetCall(
-            address(allo),
-            0,
-            abi.encodeCall(allo.changeAdmin, (_poolId, _newAdmin))
-        );
+        (bool success,) = targetCall(address(allo), 0, abi.encodeCall(allo.changeAdmin, (_poolId, _newAdmin)));
         if (success) {
             ghost_poolAdmins[_poolId] = _newAdmin;
         }
@@ -315,9 +222,7 @@ contract HandlerAllo is Setup {
         return ghost_poolIds[_idSeed % ghost_poolIds.length];
     }
 
-    function _pickPoolId(
-        uint256[] memory _seeds
-    ) internal view returns (uint256[] memory) {
+    function _pickPoolId(uint256[] memory _seeds) internal view returns (uint256[] memory) {
         uint256[] memory _poolIds = new uint256[](_seeds.length);
 
         for (uint256 _i; _i < _seeds.length; ++_i) {

test/invariant/fuzz/handlers/HandlerRegistry.t.sol

@@ -36,11 +36,16 @@ contract HandlerRegistry is Setup {
     function handler_updateProfileName(string memory _newName) public {
         // Get the profile ID
         IRegistry.Profile memory profile = registry.getProfileByAnchor(_ghost_anchorOf[msg.sender]);
+        address _owner = registry.getProfileById(profile.id).owner;
 
         // will not succeed if no profile
         (bool succ, bytes memory ret) = targetCall(
             address(registry), 0, abi.encodeWithSelector(registry.updateProfileName.selector, profile.id, _newName)
         );
+
+        if (succ) {
+            _ghost_anchorOf[_owner] = abi.decode(ret, (address));
+        }
     }
 
     function handler_updateProfileMetadata(uint256 _newProtocol, string memory _newPtr) public {
@@ -85,13 +90,13 @@ contract HandlerRegistry is Setup {
 
         // Get the profile ID
         IRegistry.Profile memory profile = registry.getProfileById(_profileId);
+        address _previousActor = registry.getProfileById(profile.id).owner;
 
         (bool succ, bytes memory ret) = targetCall(
             address(registry), 0, abi.encodeWithSelector(registry.acceptProfileOwnership.selector, profile.id)
         );
 
         if (succ) {
-            address _previousActor = _ghost_profileIdToActor[profile.id];
             _removeAnchorFromActor(_previousActor, profile.id);
             _addAnchorToActor(msg.sender, profile.anchor, profile.id);
             delete _ghost_pendingOwnershipChange[_profileSeed % _ghost_pendingOwnershipChange.length];

test/invariant/fuzz/handlers/HandlerStrategy.t.sol

@@ -16,13 +16,8 @@ contract HandlerStrategy is HandlerAllo {
         IAllo.Pool memory _pool = allo.getPool(ghost_poolIds[_poolSeed]);
 
         // Withdraw
-        (bool succ, ) = targetCall(
-            address(allo),
-            0,
-            abi.encodeCall(
-                strategy_directAllocation.withdraw,
-                (_pool.token, _amount, _recipient)
-            )
+        (bool succ,) = targetCall(
+            address(allo), 0, abi.encodeCall(strategy_directAllocation.withdraw, (_pool.token, _amount, _recipient))
         );
     }
 }