CI, Contracts: Add forge fmt --check to CI, run forge fmt

.github/workflows/ci.yml

@@ -16,6 +16,9 @@ jobs:
         with:
           version: nightly
 
+      - name: Run Linter
+        run: forge fmt --check
+
       - name: Run tests
         run: forge test --force -vvv
 
@@ -27,4 +30,4 @@ jobs:
       - name: Fork tests (polygon)
         env:
           FORK_URL: ${{ secrets.POLYGON_FORK_URL }}
-        run: forge test --match-contract FirmFactoryIntegrationTest --fork-url "$FORK_URL" -vvvv
+        run: forge test --match-contract FirmFactoryIntegrationTest --fork-url "$FORK_URL" -vvvv

src/bases/SafeAware.sol

@@ -48,6 +48,7 @@ abstract contract SafeAware {
      * @dev Modifier to be used by derived contracts to limit access control to priviledged
      * functions so they can only be called by the Safe
      */
+
     modifier onlySafe() {
         if (_msgSender() != address(safe())) {
             revert UnauthorizedNotSafe();
@@ -56,5 +57,5 @@ abstract contract SafeAware {
         _;
     }
 
-    function _msgSender() internal view virtual returns (address sender); 
+    function _msgSender() internal view virtual returns (address sender);
 }

src/bases/SemaphoreAuth.sol

@@ -6,6 +6,7 @@ import {SafeAware} from "./SafeAware.sol";
 import {ISemaphore} from "../semaphore/interfaces/ISemaphore.sol";
 
 ISemaphore constant NO_SEMAPHORE = ISemaphore(address(0));
+
 abstract contract SemaphoreAuth is SafeAware {
     // SEMAPHORE_SLOT = keccak256("firm.semaphoreauth.semaphore") - 1
     bytes32 internal constant SEMAPHORE_SLOT = 0x3e4ab72c2ecd29625ea852b1de3f6381681f0f5fb2b0bab359fabdd96dbc1b94;
@@ -31,17 +32,21 @@ abstract contract SemaphoreAuth is SafeAware {
 
     function _semaphoreCheckCall(address target, uint256 value, bytes memory data, bool isDelegateCall) internal view {
         ISemaphore semaphore_ = semaphore();
-        if (semaphore_ != NO_SEMAPHORE &&
-            !semaphore_.canPerform(address(this), target, value, data, isDelegateCall)
-        ) {
+        if (semaphore_ != NO_SEMAPHORE && !semaphore_.canPerform(address(this), target, value, data, isDelegateCall)) {
             revert ISemaphore.SemaphoreDisallowed();
         }
     }
 
-    function _semaphoreCheckCalls(address[] memory targets, uint256[] memory values, bytes[] memory datas, bool isDelegateCall) internal view {
+    function _semaphoreCheckCalls(
+        address[] memory targets,
+        uint256[] memory values,
+        bytes[] memory datas,
+        bool isDelegateCall
+    ) internal view {
         ISemaphore semaphore_ = semaphore();
-        if (semaphore_ != NO_SEMAPHORE &&
-            !semaphore_.canPerformMany(address(this), targets, values, datas, isDelegateCall)
+        if (
+            semaphore_ != NO_SEMAPHORE
+                && !semaphore_.canPerformMany(address(this), targets, values, datas, isDelegateCall)
         ) {
             revert ISemaphore.SemaphoreDisallowed();
         }

src/bases/test/SemaphoreAuth.t.sol

@@ -19,7 +19,11 @@ contract SemaphoreAuthTest is FirmTest {
     function setUp() public {
         safe = new SafeStub();
         semaphore = new SemaphoreStub();
-        semaphoreAuth = SemaphoreAuthMock(createProxy(new SemaphoreAuthMock(), abi.encodeCall(SemaphoreAuthMock.initialize, (ISafe(payable(safe)), semaphore))));
+        semaphoreAuth = SemaphoreAuthMock(
+            createProxy(
+                new SemaphoreAuthMock(), abi.encodeCall(SemaphoreAuthMock.initialize, (ISafe(payable(safe)), semaphore))
+            )
+        );
     }
 
     function testInitialState() public {
@@ -80,7 +84,8 @@ contract SemaphoreAuthTest is FirmTest {
         semaphoreAuth.semaphoreCheckCalls(targets, values, datas, false);
 
         // We filter some target (the one causing the revert) out
-        (address[] memory filteredTargets, uint256[] memory filteredValues, bytes[] memory filteredDatas) = semaphoreAuth.filterCallsToTarget(someTarget, targets, values, datas);
+        (address[] memory filteredTargets, uint256[] memory filteredValues, bytes[] memory filteredDatas) =
+            semaphoreAuth.filterCallsToTarget(someTarget, targets, values, datas);
 
         // And now it doesn't revert
         semaphoreAuth.semaphoreCheckCalls(filteredTargets, filteredValues, filteredDatas, false);
@@ -105,7 +110,8 @@ contract SemaphoreAuthTest is FirmTest {
         datas[0] = bytes("data1");
         datas[1] = bytes("data2");
 
-        (address[] memory filteredTargets, uint256[] memory filteredValues, bytes[] memory filteredDatas) = semaphoreAuth.filterCallsToTarget(someTarget, targets, values, datas);
+        (address[] memory filteredTargets, uint256[] memory filteredValues, bytes[] memory filteredDatas) =
+            semaphoreAuth.filterCallsToTarget(someTarget, targets, values, datas);
 
         assertEq(filteredTargets.length, 1);
         assertEq(filteredTargets[0], someOtherTarget);
@@ -130,7 +136,8 @@ contract SemaphoreAuthTest is FirmTest {
         datas[0] = bytes("data1");
         datas[1] = bytes("data2");
 
-        (address[] memory filteredTargets, uint256[] memory filteredValues, bytes[] memory filteredDatas) = semaphoreAuth.filterCallsToTarget(account("Another target"), targets, values, datas);
+        (address[] memory filteredTargets, uint256[] memory filteredValues, bytes[] memory filteredDatas) =
+            semaphoreAuth.filterCallsToTarget(account("Another target"), targets, values, datas);
 
         assertEq(filteredTargets.length, 2);
         assertEq(filteredTargets[0], someTarget);
@@ -158,10 +165,11 @@ contract SemaphoreAuthTest is FirmTest {
         datas[0] = bytes("data1");
         datas[1] = bytes("data2");
 
-        (address[] memory filteredTargets, uint256[] memory filteredValues, bytes[] memory filteredDatas) = semaphoreAuth.filterCallsToTarget(someTarget, targets, values, datas);
+        (address[] memory filteredTargets, uint256[] memory filteredValues, bytes[] memory filteredDatas) =
+            semaphoreAuth.filterCallsToTarget(someTarget, targets, values, datas);
 
         assertEq(filteredTargets.length, 0);
         assertEq(filteredValues.length, 0);
         assertEq(filteredDatas.length, 0);
     }
-}
+}

src/bases/test/lib/RolesAuthFlags.sol

@@ -5,4 +5,4 @@ import {ROLES_FLAG_TYPE, AddressUint8FlagsLib} from "../../RolesAuth.sol";
 
 function roleFlag(uint8 role) pure returns (address) {
     return AddressUint8FlagsLib.toFlag(role, ROLES_FLAG_TYPE);
-}
+}

src/bases/test/mocks/SemaphoreAuthMock.sol

@@ -14,12 +14,17 @@ contract SemaphoreAuthMock is FirmBase, SemaphoreAuth {
     }
 
     // Make ISemaphore internal functions public for testing
-    
+
     function semaphoreCheckCall(address target, uint256 value, bytes memory data, bool isDelegateCall) public view {
         _semaphoreCheckCall(target, value, data, isDelegateCall);
     }
 
-    function semaphoreCheckCalls(address[] memory targets, uint256[] memory values, bytes[] memory datas, bool isDelegateCall) public view {
+    function semaphoreCheckCalls(
+        address[] memory targets,
+        uint256[] memory values,
+        bytes[] memory datas,
+        bool isDelegateCall
+    ) public view {
         _semaphoreCheckCalls(targets, values, datas, isDelegateCall);
     }
 
@@ -31,4 +36,4 @@ contract SemaphoreAuthMock is FirmBase, SemaphoreAuth {
     ) public pure returns (address[] memory, uint256[] memory, bytes[] memory) {
         return _filterCallsToTarget(filteredTarget, targets, values, calldatas);
     }
-}
+}

src/bases/test/mocks/SemaphoreStub.sol

@@ -4,8 +4,8 @@ pragma solidity 0.8.17;
 import {ISemaphore} from "src/semaphore/interfaces/ISemaphore.sol";
 
 contract SemaphoreStub is ISemaphore {
-    mapping (address => bool) public disallowedTargets;
-    mapping (address => bool) public disallowedCallers;
+    mapping(address => bool) public disallowedTargets;
+    mapping(address => bool) public disallowedCallers;
 
     function setDisallowed(address addr, bool targetOrCaller) external {
         if (targetOrCaller) {
@@ -25,12 +25,18 @@ contract SemaphoreStub is ISemaphore {
         return true;
     }
 
-    function canPerformMany(address caller, address[] calldata targets, uint256[] calldata values, bytes[] calldata calldatas, bool isDelegateCall) external view returns (bool) {
+    function canPerformMany(
+        address caller,
+        address[] calldata targets,
+        uint256[] calldata values,
+        bytes[] calldata calldatas,
+        bool isDelegateCall
+    ) external view returns (bool) {
         for (uint256 i = 0; i < targets.length; i++) {
             if (!canPerform(caller, targets[i], values[i], calldatas[i], isDelegateCall)) {
                 return false;
             }
         }
         return true;
     }
-}
+}

src/captable/Captable.sol

@@ -347,7 +347,7 @@ contract Captable is FirmBase, BouncerChecker, ICaptableVotes {
         if (classBalance == 0) {
             revert AccountIsNonHolder(account, classId);
         }
-        
+
         _setController(account, classId, classBalance, controller, controllerParams);
     }
 

src/captable/controllers/test/AccountControllerTest.sol

@@ -19,9 +19,11 @@ abstract contract AccountControllerTest is FirmTest {
 
     function setUp() public virtual {
         safe = new SafeStub();
-        captable = Captable(createProxy(new Captable(), abi.encodeCall(Captable.initialize, ("TestCo", safe, address(0)))));
+        captable =
+            Captable(createProxy(new Captable(), abi.encodeCall(Captable.initialize, ("TestCo", safe, address(0)))));
         vm.prank(address(safe));
-        (classId, token) = captable.createClass("Common", "TST.A", authorizedAmount, NO_CONVERSION_FLAG, 1, ALLOW_ALL_BOUNCER);
+        (classId, token) =
+            captable.createClass("Common", "TST.A", authorizedAmount, NO_CONVERSION_FLAG, 1, ALLOW_ALL_BOUNCER);
     }
 
     function controller() internal view virtual returns (AccountController);
@@ -33,4 +35,4 @@ abstract contract AccountControllerTest is FirmTest {
         assertEq(address(controller().safe()), address(safe));
         assertUnsStrg(address(controller()), "firm.safeaware.safe", address(safe));
     }
-}
+}

src/captable/controllers/test/VestingController.t.sol

@@ -22,7 +22,11 @@ contract VestingControllerTest is AccountControllerTest {
         vm.warp(0);
 
         roles = new RolesStub();
-        vesting = VestingController(createProxy(new VestingController(), abi.encodeCall(VestingController.initialize, (captable, roles, address(0)))));
+        vesting = VestingController(
+            createProxy(
+                new VestingController(), abi.encodeCall(VestingController.initialize, (captable, roles, address(0)))
+            )
+        );
 
         roles.setRole(REVOKER, REVOKER_ROLE, true);
     }
@@ -65,22 +69,36 @@ contract VestingControllerTest is AccountControllerTest {
 
     function testCannotAddAccountWithInvalidParameters() public {
         vm.startPrank(address(captable));
-        
+
         vm.expectRevert(abi.encodeWithSelector(VestingController.InvalidVestingParameters.selector));
-        vesting.addAccount(HOLDER, classId, authorizedAmount - 1, abi.encode(VestingController.VestingParams({
-            startDate: 21,
-            cliffDate: 20,
-            endDate: 30,
-            revoker: roleFlag(REVOKER_ROLE)
-        })));
+        vesting.addAccount(
+            HOLDER,
+            classId,
+            authorizedAmount - 1,
+            abi.encode(
+                VestingController.VestingParams({
+                    startDate: 21,
+                    cliffDate: 20,
+                    endDate: 30,
+                    revoker: roleFlag(REVOKER_ROLE)
+                })
+            )
+        );
 
         vm.expectRevert(abi.encodeWithSelector(VestingController.InvalidVestingParameters.selector));
-        vesting.addAccount(HOLDER, classId, authorizedAmount - 1, abi.encode(VestingController.VestingParams({
-            startDate: 10,
-            cliffDate: 31,
-            endDate: 30,
-            revoker: roleFlag(REVOKER_ROLE)
-        })));
+        vesting.addAccount(
+            HOLDER,
+            classId,
+            authorizedAmount - 1,
+            abi.encode(
+                VestingController.VestingParams({
+                    startDate: 10,
+                    cliffDate: 31,
+                    endDate: 30,
+                    revoker: roleFlag(REVOKER_ROLE)
+                })
+            )
+        );
 
         vm.stopPrank();
     }
@@ -106,11 +124,11 @@ contract VestingControllerTest is AccountControllerTest {
     }
 
     function testRevokerCanRevokeAtThisTime() public {
-        (,uint40 cliffDate,) = testCaptableAddsAccount();
+        (, uint40 cliffDate,) = testCaptableAddsAccount();
         vm.warp(cliffDate);
         vm.prank(REVOKER);
         vesting.revokeVesting(HOLDER, classId);
-        
+
         assertEq(captable.balanceOf(HOLDER, classId), issuedAmount / 2);
 
         assertAccountWasCleanedUp();
@@ -121,14 +139,14 @@ contract VestingControllerTest is AccountControllerTest {
         vm.warp(startDate);
         vm.prank(REVOKER);
         vesting.revokeVesting(HOLDER, classId, cliffDate);
-        
+
         assertEq(captable.balanceOf(HOLDER, classId), issuedAmount / 2);
 
         assertAccountWasCleanedUp();
     }
 
     function testRevokerCantRevokeInThePast() public {
-        (,uint40 cliffDate,) = testCaptableAddsAccount();
+        (, uint40 cliffDate,) = testCaptableAddsAccount();
         vm.warp(cliffDate);
         vm.prank(REVOKER);
         vm.expectRevert(abi.encodeWithSelector(VestingController.EffectiveDateInThePast.selector));
@@ -183,4 +201,4 @@ contract VestingControllerTest is AccountControllerTest {
         vm.expectRevert(abi.encodeWithSelector(AccountController.AccountDoesntExist.selector));
         vesting.revokeVesting(HOLDER, classId, 1);
     }
-}
+}

src/captable/test/Captable.t.sol

@@ -145,11 +145,12 @@ contract CaptableInitTest is BaseCaptableTest {
 
         for (uint256 i = 0; i < CLASSES_LIMIT; i++) {
             vm.prank(address(safe));
-            (uint256 classId, EquityToken token) = captable.createClass("", "", maxAuthorizable, NO_CONVERSION_FLAG, maxVotingWeight, ALLOW_ALL_BOUNCER);
+            (uint256 classId, EquityToken token) =
+                captable.createClass("", "", maxAuthorizable, NO_CONVERSION_FLAG, maxVotingWeight, ALLOW_ALL_BOUNCER);
 
             vm.prank(address(safe));
             captable.issue(HOLDER1, classId, maxAuthorizable);
-            
+
             vm.prank(address(HOLDER1));
             token.delegate(HOLDER1);
         }

src/captable/test/EquityToken.t.sol

@@ -45,13 +45,13 @@ contract EquityTokenTest is BaseCaptableTest {
         token.forcedTransfer(HOLDER2, HOLDER1, 1);
         assertEq(token.balanceOf(HOLDER1), HOLDER_BALANCE + 1);
         assertEq(token.balanceOf(HOLDER2), 0);
-        
+
         vm.stopPrank();
     }
 
     function testNonCaptableCannotPerformAdminActions() public {
         bytes memory onlyCaptableError = abi.encodeWithSelector(EquityToken.UnauthorizedNotCaptable.selector);
-        
+
         vm.startPrank(address(safe));
 
         vm.expectRevert(onlyCaptableError);

src/captable/test/lib/BouncerFlags.sol

@@ -1,8 +1,10 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.17;
 
-import {IBouncer, EmbeddedBouncerType, EMBEDDED_BOUNCER_FLAG_TYPE, AddressUint8FlagsLib} from "../../BouncerChecker.sol";
+import {
+    IBouncer, EmbeddedBouncerType, EMBEDDED_BOUNCER_FLAG_TYPE, AddressUint8FlagsLib
+} from "../../BouncerChecker.sol";
 
 function bouncerFlag(EmbeddedBouncerType bouncer) pure returns (IBouncer) {
-  return IBouncer(AddressUint8FlagsLib.toFlag(uint8(bouncer), EMBEDDED_BOUNCER_FLAG_TYPE));
-}
+    return IBouncer(AddressUint8FlagsLib.toFlag(uint8(bouncer), EMBEDDED_BOUNCER_FLAG_TYPE));
+}