Vectorized · Vectorized · Oct 28, 2025 · Oct 28, 2025 · Oct 28, 2025
diff --git a/foundry.toml b/foundry.toml
@@ -47,6 +47,7 @@ remappings = [
 
 [fmt]
 line_length = 100 # While we allow up to 120, we lint at 100 for readability.
+ignore = ["src/accounts/EIP7702Proxy.sol"]
 
 [profile.default.fuzz]
 runs = 256

diff --git a/src/accounts/ERC1271.sol b/src/accounts/ERC1271.sol
@@ -114,7 +114,9 @@ abstract contract ERC1271 is EIP712 {
         virtual
         returns (bool result)
     {
-        if (_erc1271CallerIsSafe()) result = _erc1271IsValidSignatureNowCalldata(hash, signature);
+        if (_erc1271CallerIsSafe()) {
+            result = _erc1271IsValidSignatureNowCalldata(hash, signature);
+        }
     }
 
     /// @dev ERC1271 signature validation (Nested EIP-712 workflow).

diff --git a/src/accounts/ERC4337.sol b/src/accounts/ERC4337.sol
@@ -340,14 +340,13 @@ abstract contract ERC4337 is Ownable, UUPSUpgradeable, Receiver, ERC1271 {
         assembly {
             mstore(0x20, address()) // Store the `account` argument.
             mstore(0x00, 0x70a08231) // `balanceOf(address)`.
-            result :=
-                mul( // Returns 0 if the EntryPoint does not exist.
-                    mload(0x20),
-                    and( // The arguments of `and` are evaluated from right to left.
-                        gt(returndatasize(), 0x1f), // At least 32 bytes returned.
-                        staticcall(gas(), ep, 0x1c, 0x24, 0x20, 0x20)
-                    )
+            result := mul( // Returns 0 if the EntryPoint does not exist.
+                mload(0x20),
+                and( // The arguments of `and` are evaluated from right to left.
+                    gt(returndatasize(), 0x1f), // At least 32 bytes returned.
+                    staticcall(gas(), ep, 0x1c, 0x24, 0x20, 0x20)
                 )
+            )
         }
     }
 
@@ -356,6 +355,7 @@ abstract contract ERC4337 is Ownable, UUPSUpgradeable, Receiver, ERC1271 {
         address ep = entryPoint();
         /// @solidity memory-safe-assembly
         assembly {
+
             // The EntryPoint has balance accounting logic in the `receive()` function, as defined in ERC-4337.
             // forgefmt: disable-next-item
             if iszero(mul(extcodesize(ep), call(gas(), ep, callvalue(), codesize(), 0x00, codesize(), 0x00))) {

diff --git a/src/accounts/ERC6551.sol b/src/accounts/ERC6551.sol
@@ -111,14 +111,13 @@ abstract contract ERC6551 is UUPSUpgradeable, Receiver, ERC1271 {
                 let tokenContract := mload(0x20)
                 // `tokenId` is already at 0x40.
                 mstore(0x20, 0x6352211e) // `ownerOf(uint256)`.
-                result :=
-                    mul( // Returns `address(0)` on failure or if contract does not exist.
-                        mload(0x20),
-                        and(
-                            gt(returndatasize(), 0x1f),
-                            staticcall(gas(), tokenContract, 0x3c, 0x24, 0x20, 0x20)
-                        )
+                result := mul( // Returns `address(0)` on failure or if contract does not exist.
+                    mload(0x20),
+                    and(
+                        gt(returndatasize(), 0x1f),
+                        staticcall(gas(), tokenContract, 0x3c, 0x24, 0x20, 0x20)
                     )
+                )
             }
             mstore(0x40, m) // Restore the free memory pointer.
         }

diff --git a/src/accounts/LibERC7579.sol b/src/accounts/LibERC7579.sol
@@ -248,8 +248,9 @@ library LibERC7579 {
     function hasOpData(bytes calldata executionData) internal pure returns (bool result) {
         /// @solidity memory-safe-assembly
         assembly {
-            result :=
-                iszero(or(lt(executionData.length, 0x40), lt(calldataload(executionData.offset), 0x40)))
+            result := iszero(
+                or(lt(executionData.length, 0x40), lt(calldataload(executionData.offset), 0x40))
+            )
         }
     }
 

diff --git a/src/accounts/Timelock.sol b/src/accounts/Timelock.sol
@@ -69,7 +69,6 @@ contract Timelock is ERC7821, EnumerableRoles {
         Waiting, // 1.
         Ready, // 2.
         Done // 3.
-
     }
 
     /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
@@ -384,7 +383,9 @@ contract Timelock is ERC7821, EnumerableRoles {
         Call[] calldata calls,
         bytes calldata opData
     ) internal virtual override(ERC7821) {
-        if (!hasRole(OPEN_ROLE_HOLDER, EXECUTOR_ROLE)) _checkRole(EXECUTOR_ROLE);
+        if (!hasRole(OPEN_ROLE_HOLDER, EXECUTOR_ROLE)) {
+            _checkRole(EXECUTOR_ROLE);
+        }
         bytes32 id;
         uint256 s;
         /// @solidity memory-safe-assembly

diff --git a/src/auth/EnumerableRoles.sol b/src/auth/EnumerableRoles.sol
@@ -296,11 +296,10 @@ abstract contract EnumerableRoles {
         /// @solidity memory-safe-assembly
         assembly {
             mstore(0x00, 0x8da5cb5b) // `owner()`.
-            result :=
-                and(
-                    and(eq(caller(), mload(0x00)), gt(returndatasize(), 0x1f)),
-                    staticcall(gas(), address(), 0x1c, 0x04, 0x00, 0x20)
-                )
+            result := and(
+                and(eq(caller(), mload(0x00)), gt(returndatasize(), 0x1f)),
+                staticcall(gas(), address(), 0x1c, 0x04, 0x00, 0x20)
+            )
         }
     }
 

diff --git a/src/auth/TimedRoles.sol b/src/auth/TimedRoles.sol
@@ -167,10 +167,12 @@ abstract contract TimedRoles {
     }
 
     /// @dev Checks that the caller is authorized to set the timed role.
-    function _authorizeSetTimedRole(address holder, uint256 timedRole, uint40 start, uint40 expires)
-        internal
-        virtual
-    {
+    function _authorizeSetTimedRole(
+        address holder,
+        uint256 timedRole,
+        uint40 start,
+        uint40 expires
+    ) internal virtual {
         if (!_timedRolesSenderIsContractOwner()) _revertTimedRolesUnauthorized();
         // Silence compiler warning on unused variables.
         (holder, timedRole, start, expires) = (holder, timedRole, start, expires);
@@ -193,8 +195,9 @@ abstract contract TimedRoles {
                 encodedTimeRoles := add(0x20, encodedTimeRoles)
                 mstore(0x00, mload(encodedTimeRoles))
                 let p := sload(keccak256(0x00, 0x38))
-                result :=
-                    iszero(or(lt(timestamp(), shr(216, p)), gt(timestamp(), and(0xffffffffff, p))))
+                result := iszero(
+                    or(lt(timestamp(), shr(216, p)), gt(timestamp(), and(0xffffffffff, p)))
+                )
             }
         }
     }
@@ -263,11 +266,10 @@ abstract contract TimedRoles {
         /// @solidity memory-safe-assembly
         assembly {
             mstore(0x00, 0x8da5cb5b) // `owner()`.
-            result :=
-                and(
-                    and(eq(caller(), mload(0x00)), gt(returndatasize(), 0x1f)),
-                    staticcall(gas(), address(), 0x1c, 0x04, 0x00, 0x20)
-                )
+            result := and(
+                and(eq(caller(), mload(0x00)), gt(returndatasize(), 0x1f)),
+                staticcall(gas(), address(), 0x1c, 0x04, 0x00, 0x20)
+            )
         }
     }
 

diff --git a/src/tokens/ERC4626.sol b/src/tokens/ERC4626.sol
@@ -129,13 +129,12 @@ abstract contract ERC4626 is ERC20 {
             // Store the function selector of `decimals()`.
             mstore(0x00, 0x313ce567)
             // Arguments are evaluated last to first.
-            success :=
-                and(
-                    // Returned value is less than 256, at left-padded to 32 bytes.
-                    and(lt(mload(0x00), 0x100), gt(returndatasize(), 0x1f)),
-                    // The staticcall succeeds.
-                    staticcall(gas(), underlying, 0x1c, 0x04, 0x00, 0x20)
-                )
+            success := and(
+                // Returned value is less than 256, at left-padded to 32 bytes.
+                and(lt(mload(0x00), 0x100), gt(returndatasize(), 0x1f)),
+                // The staticcall succeeds.
+                staticcall(gas(), underlying, 0x1c, 0x04, 0x00, 0x20)
+            )
             result := mul(mload(0x00), success)
         }
     }

diff --git a/src/tokens/ERC6909.sol b/src/tokens/ERC6909.sol
@@ -486,10 +486,7 @@ abstract contract ERC6909 {
     /// @dev Sets `amount` as the allowance of `spender` for `owner` for token `id`.
     ///
     /// Emits a {Approval} event.
-    function _approve(address owner, address spender, uint256 id, uint256 amount)
-        internal
-        virtual
-    {
+    function _approve(address owner, address spender, uint256 id, uint256 amount) internal virtual {
         /// @solidity memory-safe-assembly
         assembly {
             // Compute the allowance slot and store the amount.
@@ -535,13 +532,11 @@ abstract contract ERC6909 {
     /// This includes minting and burning.
     function _beforeTokenTransfer(address from, address to, uint256 id, uint256 amount)
         internal
-        virtual
-    {}
+        virtual {}
 
     /// @dev Hook that is called after any transfer of tokens.
     /// This includes minting and burning.
     function _afterTokenTransfer(address from, address to, uint256 id, uint256 amount)
         internal
-        virtual
-    {}
+        virtual {}
 }
diff --git a/src/utils/Base58.sol b/src/utils/Base58.sol
@@ -98,9 +98,10 @@ library Base58 {
                     o := add(o, w)
                     mstore8(o, mload(mod(v, 58)))
                 }
-                for {} iszero(byte(z, data)) { z := add(z, 1) } {} // Just loop, `z` is often tiny.
+                for {} // Just loop, `z` is often tiny.
+                 iszero(byte(z, data)) { z := add(z, 1) } {}
             }
-            if z { mstore(sub(o, 0x20), mul(div(w, 0xff), 49)) } // '1111...1111' in ASCII.
+            if z { mstore(sub(o, 0x20), mul(div(w, 0xff), 49))} // '1111...1111' in ASCII.
             o := sub(o, z)
 
             let n := sub(e, o) // Compute the final length.

diff --git a/src/utils/Base64.sol b/src/utils/Base64.sol
@@ -84,11 +84,7 @@ library Base64 {
 
     /// @dev Encodes `data` using the base64 encoding described in RFC 4648.
     /// Equivalent to `encode(data, fileSafe, false)`.
-    function encode(bytes memory data, bool fileSafe)
-        internal
-        pure
-        returns (string memory result)
-    {
+    function encode(bytes memory data, bool fileSafe) internal pure returns (string memory result) {
         result = encode(data, fileSafe, false);
     }
 

diff --git a/src/utils/DateTimeLib.sol b/src/utils/DateTimeLib.sol
@@ -181,8 +181,10 @@ library DateTimeLib {
         assembly {
             // `daysInMonths = [31,28,31,30,31,30,31,31,30,31,30,31]`.
             // `result = daysInMonths[month - 1] + isLeapYear(year)`.
-            result :=
-                add(byte(month, shl(152, 0x1f1c1f1e1f1e1f1f1e1f1e1f)), and(eq(month, 2), flag))
+            result := add(
+                byte(month, shl(152, 0x1f1c1f1e1f1e1f1f1e1f1e1f)),
+                and(eq(month, 2), flag)
+            )
         }
     }
 
@@ -206,11 +208,10 @@ library DateTimeLib {
         uint256 md = daysInMonth(year, month);
         /// @solidity memory-safe-assembly
         assembly {
-            result :=
-                and(
-                    lt(sub(year, 1970), sub(MAX_SUPPORTED_YEAR, 1969)),
-                    and(lt(sub(month, 1), 12), lt(sub(day, 1), md))
-                )
+            result := and(
+                lt(sub(year, 1970), sub(MAX_SUPPORTED_YEAR, 1969)),
+                and(lt(sub(month, 1), 12), lt(sub(day, 1), md))
+            )
         }
     }
 

diff --git a/src/utils/DynamicArrayLib.sol b/src/utils/DynamicArrayLib.sol
@@ -442,7 +442,9 @@ library DynamicArrayLib {
             let arrLen := mload(arrData)
             if iszero(lt(n, arrLen)) {
                 calldatacopy(
-                    add(arrData, shl(5, add(1, arrLen))), calldatasize(), shl(5, sub(n, arrLen))
+                    add(arrData, shl(5, add(1, arrLen))),
+                    calldatasize(),
+                    shl(5, sub(n, arrLen))
                 )
             }
             mstore(arrData, n)
@@ -802,23 +804,15 @@ library DynamicArrayLib {
     }
 
     /// @dev Returns the underlying array as a `uint256[]`.
-    function asUint256Array(DynamicArray memory a)
-        internal
-        pure
-        returns (uint256[] memory result)
-    {
+    function asUint256Array(DynamicArray memory a) internal pure returns (uint256[] memory result) {
         /// @solidity memory-safe-assembly
         assembly {
             result := mload(a)
         }
     }
 
     /// @dev Returns the underlying array as a `address[]`.
-    function asAddressArray(DynamicArray memory a)
-        internal
-        pure
-        returns (address[] memory result)
-    {
+    function asAddressArray(DynamicArray memory a) internal pure returns (address[] memory result) {
         /// @solidity memory-safe-assembly
         assembly {
             result := mload(a)
@@ -834,11 +828,7 @@ library DynamicArrayLib {
     }
 
     /// @dev Returns the underlying array as a `bytes32[]`.
-    function asBytes32Array(DynamicArray memory a)
-        internal
-        pure
-        returns (bytes32[] memory result)
-    {
+    function asBytes32Array(DynamicArray memory a) internal pure returns (bytes32[] memory result) {
         /// @solidity memory-safe-assembly
         assembly {
             result := mload(a)

diff --git a/src/utils/ECDSA.sol b/src/utils/ECDSA.sol
@@ -29,7 +29,8 @@ library ECDSA {
     /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
 
     /// @dev The order of the secp256k1 elliptic curve.
-    uint256 internal constant N = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141;
+    uint256 internal constant N =
+        0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141;
 
     /// @dev `N/2 + 1`. Used for checking the malleability of the signature.
     uint256 private constant _HALF_N_PLUS_1 =