add solidity pretty

ququzone · Nov 27, 2023 · 5a53e09 · 5a53e09
1 parent 92d7fff
commit 5a53e09
Show file tree

Hide file tree

Showing 139 changed files with 6,824 additions and 4,491 deletions.
diff --git a/.prettierrc b/.prettierrc
@@ -1,5 +1,15 @@
 {
-    "semi": false,
+    "printWidth": 120,
     "singleQuote": true,
-    "printWidth": 120
+    "trailingComma": "all",
+    "arrowParens": "avoid",
+    "overrides": [
+      {
+        "files": "*.sol",
+        "options": {
+          "singleQuote": false
+        }
+      }
+    ],
+    "plugins": ["prettier-plugin-solidity"]
 }
diff --git a/contracts/SmartAccount.sol b/contracts/SmartAccount.sol
@@ -23,17 +23,18 @@ contract SmartAccount is
         _disableInitializers();
     }
 
-    function initialize(address defalutCallbackHandler, address[] calldata validators, bytes[] calldata data)
-        external
-        initializer
-    {
+    function initialize(
+        address defalutCallbackHandler,
+        address[] calldata validators,
+        bytes[] calldata data
+    ) external initializer {
         if (validators.length != data.length) {
             revert WrongArrayLength();
         }
         _setFallbackHandler(defalutCallbackHandler);
         _setupValidators();
         _setupRecoverors();
-        for (uint256 i = 0; i < validators.length;) {
+        for (uint256 i = 0; i < validators.length; ) {
             _enableValidator(validators[i], data[i]);
             unchecked {
                 i++;
@@ -45,12 +46,10 @@ contract SmartAccount is
         return _entryPoint();
     }
 
-    function _validateSignature(UserOperation calldata userOp, bytes32 userOpHash)
-        internal
-        virtual
-        override
-        returns (uint256 validationData)
-    {
+    function _validateSignature(
+        UserOperation calldata userOp,
+        bytes32 userOpHash
+    ) internal virtual override returns (uint256 validationData) {
         (address validator, bytes memory signature) = abi.decode(userOp.signature, (address, bytes));
 
         if (!isValidatorEnabled(validator)) {

diff --git a/contracts/SmartAccountFactory.sol b/contracts/SmartAccountFactory.sol
@@ -16,10 +16,11 @@ contract SmartAccountFactory {
         accountImplementation = new SmartAccount(_entryPoint);
     }
 
-    function createAccount(address[] calldata validators, bytes[] calldata data, uint256 salt)
-        public
-        returns (SmartAccount ret)
-    {
+    function createAccount(
+        address[] calldata validators,
+        bytes[] calldata data,
+        uint256 salt
+    ) public returns (SmartAccount ret) {
         address addr = getAddress(validators, data, salt);
         uint256 codeSize = addr.code.length;
         if (codeSize > 0) {
@@ -28,28 +29,30 @@ contract SmartAccountFactory {
         ret = SmartAccount(
             payable(
                 new ERC1967Proxy{salt: bytes32(salt)}(
-                    address(accountImplementation), abi.encodeCall(SmartAccount.initialize, (handler, validators, data))
+                    address(accountImplementation),
+                    abi.encodeCall(SmartAccount.initialize, (handler, validators, data))
                 )
             )
         );
     }
 
-    function getAddress(address[] calldata validators, bytes[] calldata data, uint256 salt)
-        public
-        view
-        returns (address)
-    {
-        return Create2.computeAddress(
-            bytes32(salt),
-            keccak256(
-                abi.encodePacked(
-                    type(ERC1967Proxy).creationCode,
-                    abi.encode(
-                        address(accountImplementation),
-                        abi.encodeCall(SmartAccount.initialize, (handler, validators, data))
+    function getAddress(
+        address[] calldata validators,
+        bytes[] calldata data,
+        uint256 salt
+    ) public view returns (address) {
+        return
+            Create2.computeAddress(
+                bytes32(salt),
+                keccak256(
+                    abi.encodePacked(
+                        type(ERC1967Proxy).creationCode,
+                        abi.encode(
+                            address(accountImplementation),
+                            abi.encodeCall(SmartAccount.initialize, (handler, validators, data))
+                        )
                     )
                 )
-            )
-        );
+            );
     }
 }
diff --git a/contracts/core/ExecutionManager.sol b/contracts/core/ExecutionManager.sol
@@ -60,22 +60,23 @@ abstract contract ExecutionManager is Authority {
         _execute(dest, value, func);
     }
 
-    function executeBatch(address[] calldata dest, uint256[] calldata value, bytes[] calldata func)
-        external
-        onlyEntryPoint
-    {
+    function executeBatch(
+        address[] calldata dest,
+        uint256[] calldata value,
+        bytes[] calldata func
+    ) external onlyEntryPoint {
         if (dest.length != func.length || (value.length != 0 && value.length != func.length)) {
             revert WrongArrayLength();
         }
         if (value.length == 0) {
-            for (uint256 i = 0; i < dest.length;) {
+            for (uint256 i = 0; i < dest.length; ) {
                 _execute(dest[i], 0, func[i]);
                 unchecked {
                     i++;
                 }
             }
         } else {
-            for (uint256 i = 0; i < dest.length;) {
+            for (uint256 i = 0; i < dest.length; ) {
                 _execute(dest[i], value[i], func[i]);
                 unchecked {
                     i++;

diff --git a/contracts/core/FallbackManager.sol b/contracts/core/FallbackManager.sol
@@ -16,15 +16,19 @@ abstract contract FallbackManager is Authority {
         bytes32 slot = FALLBACK_HANDLER_STORAGE_SLOT;
         assembly {
             let handler := sload(slot)
-            if iszero(handler) { return(0, 0) }
+            if iszero(handler) {
+                return(0, 0)
+            }
             calldatacopy(0, 0, calldatasize())
             // The msg.sender address is shifted to the left by 12 bytes to remove the padding
             // Then the address without padding is stored right after the calldata
             mstore(calldatasize(), shl(96, caller()))
             // Add 20 bytes for the address appended add the end
             let success := call(gas(), handler, 0, 0, add(calldatasize(), 20), 0, 0)
             returndatacopy(0, 0, returndatasize())
-            if iszero(success) { revert(0, returndatasize()) }
+            if iszero(success) {
+                revert(0, returndatasize())
+            }
             return(0, returndatasize())
         }
     }

diff --git a/contracts/core/RecoveryManager.sol b/contracts/core/RecoveryManager.sol
@@ -16,11 +16,10 @@ abstract contract RecoveryManager is Authority {
 
     mapping(address => address) internal recoverors;
 
-    function getRecoverorsPaginated(address start, uint256 pageSize)
-        external
-        view
-        returns (address[] memory array, address next)
-    {
+    function getRecoverorsPaginated(
+        address start,
+        uint256 pageSize
+    ) external view returns (address[] memory array, address next) {
         return recoverors.page(start, pageSize);
     }
 

diff --git a/contracts/core/ValidatorManager.sol b/contracts/core/ValidatorManager.sol
@@ -13,18 +13,21 @@ abstract contract ValidatorManager is Authority {
 
     error ValidatorCannotBeZeroOrSentinel(address validator);
     error ValidatorAlreadyEnabled(address validator);
-    error ValidatorAndPrevValidatorMismatch(address expectedValidator, address returnedValidator, address prevValidator);
+    error ValidatorAndPrevValidatorMismatch(
+        address expectedValidator,
+        address returnedValidator,
+        address prevValidator
+    );
 
     event EnabledValidator(address validator);
     event DisabledValidator(address validator);
 
     mapping(address => address) internal validators;
 
-    function getValidatorsPaginated(address start, uint256 pageSize)
-        external
-        view
-        returns (address[] memory array, address next)
-    {
+    function getValidatorsPaginated(
+        address start,
+        uint256 pageSize
+    ) external view returns (address[] memory array, address next) {
         return validators.page(start, pageSize);
     }
 

diff --git a/contracts/interfaces/IValidator.sol b/contracts/interfaces/IValidator.sol
@@ -5,10 +5,11 @@ import {UserOperation} from "@account-abstraction/contracts/interfaces/UserOpera
 import "./Metadata.sol";
 
 interface IValidator is Metadata {
-    function validateSignature(UserOperation calldata userOp, bytes32 userOpHash, bytes calldata signature)
-        external
-        payable
-        returns (uint256 validationData);
+    function validateSignature(
+        UserOperation calldata userOp,
+        bytes32 userOpHash,
+        bytes calldata signature
+    ) external payable returns (uint256 validationData);
 
     function validCaller(address caller, bytes calldata data) external view returns (bool);
 

diff --git a/contracts/libraries/LinkedAddressList.sol b/contracts/libraries/LinkedAddressList.sol
@@ -5,11 +5,11 @@ library LinkedAddressList {
     address internal constant SENTINEL = address(0x1);
     uint160 internal constant SENTINEL_UINT = 1;
 
-    function page(mapping(address => address) storage target, address start, uint256 pageSize)
-        internal
-        view
-        returns (address[] memory array, address next)
-    {
+    function page(
+        mapping(address => address) storage target,
+        address start,
+        uint256 pageSize
+    ) internal view returns (address[] memory array, address next) {
         array = new address[](pageSize);
 
         uint256 count;

diff --git a/contracts/paymaster/VerifyingPaymaster.sol b/contracts/paymaster/VerifyingPaymaster.sol
@@ -35,27 +35,34 @@ contract VerifyingPaymaster is BasePaymaster {
         }
     }
 
-    function getHash(UserOperation calldata userOp, uint48 validUntil, uint48 validAfter)
-        public
-        view
-        returns (bytes32)
-    {
-        return keccak256(
-            abi.encode(
-                pack(userOp), block.chainid, address(this), senderNonce[userOp.getSender()], validUntil, validAfter
-            )
-        );
+    function getHash(
+        UserOperation calldata userOp,
+        uint48 validUntil,
+        uint48 validAfter
+    ) public view returns (bytes32) {
+        return
+            keccak256(
+                abi.encode(
+                    pack(userOp),
+                    block.chainid,
+                    address(this),
+                    senderNonce[userOp.getSender()],
+                    validUntil,
+                    validAfter
+                )
+            );
     }
 
-    function _validatePaymasterUserOp(UserOperation calldata userOp, bytes32, /*userOpHash*/ uint256 requiredPreFund)
-        internal
-        override
-        returns (bytes memory context, uint256 validationData)
-    {
+    function _validatePaymasterUserOp(
+        UserOperation calldata userOp,
+        bytes32,
+        /*userOpHash*/ uint256 requiredPreFund
+    ) internal override returns (bytes memory context, uint256 validationData) {
         (requiredPreFund);
 
-        (uint48 validUntil, uint48 validAfter, bytes calldata signature) =
-            parsePaymasterAndData(userOp.paymasterAndData);
+        (uint48 validUntil, uint48 validAfter, bytes calldata signature) = parsePaymasterAndData(
+            userOp.paymasterAndData
+        );
         require(
             signature.length == 64 || signature.length == 65,
             "VerifyingPaymaster: invalid signature length in paymasterAndData"
@@ -70,13 +77,13 @@ contract VerifyingPaymaster is BasePaymaster {
         return ("", _packValidationData(false, validUntil, validAfter));
     }
 
-    function parsePaymasterAndData(bytes calldata paymasterAndData)
-        public
-        pure
-        returns (uint48 validUntil, uint48 validAfter, bytes calldata signature)
-    {
-        (validUntil, validAfter) =
-            abi.decode(paymasterAndData[VALID_TIMESTAMP_OFFSET:SIGNATURE_OFFSET], (uint48, uint48));
+    function parsePaymasterAndData(
+        bytes calldata paymasterAndData
+    ) public pure returns (uint48 validUntil, uint48 validAfter, bytes calldata signature) {
+        (validUntil, validAfter) = abi.decode(
+            paymasterAndData[VALID_TIMESTAMP_OFFSET:SIGNATURE_OFFSET],
+            (uint48, uint48)
+        );
         signature = paymasterAndData[SIGNATURE_OFFSET:];
     }
 

diff --git a/contracts/validators/ECDSAValidator.sol b/contracts/validators/ECDSAValidator.sol
@@ -14,12 +14,11 @@ contract ECDSAValidator is BaseValidator {
 
     mapping(address => address) public owner;
 
-    function validateSignature(UserOperation calldata userOp, bytes32 userOpHash, bytes calldata signature)
-        external
-        payable
-        override
-        returns (uint256 validationData)
-    {
+    function validateSignature(
+        UserOperation calldata userOp,
+        bytes32 userOpHash,
+        bytes calldata signature
+    ) external payable override returns (uint256 validationData) {
         address _owner = owner[userOp.sender];
         bytes32 hash = ECDSA.toEthSignedMessageHash(userOpHash);
         if (_owner != ECDSA.recover(hash, signature)) {

diff --git a/contracts/validators/OIDCSessionOnlyValidator.sol b/contracts/validators/OIDCSessionOnlyValidator.sol
@@ -7,23 +7,24 @@ import "../common/Contants.sol";
 import "./BaseValidator.sol";
 
 interface IVerifier {
-    function verifyProof(uint256[2] memory a, uint256[2][2] memory b, uint256[2] memory c, uint256[2] memory input)
-        external
-        view
-        returns (bool r);
+    function verifyProof(
+        uint256[2] memory a,
+        uint256[2][2] memory b,
+        uint256[2] memory c,
+        uint256[2] memory input
+    ) external view returns (bool r);
 }
 
 // OIDC ZK based validator that can only to add session validator
 contract OIDCSessionOnlyValidator is BaseValidator {
     string public constant override NAME = "OIDC Validator";
     string public constant override VERSION = "0.0.1";
 
-    function validateSignature(UserOperation calldata userOp, bytes32 userOpHash, bytes calldata signature)
-        external
-        payable
-        override
-        returns (uint256 validationData)
-    {}
+    function validateSignature(
+        UserOperation calldata userOp,
+        bytes32 userOpHash,
+        bytes calldata signature
+    ) external payable override returns (uint256 validationData) {}
 
     function validCaller(address caller, bytes calldata data) external view override returns (bool) {}
 

diff --git a/contracts/validators/p256/Base64.sol b/contracts/validators/p256/Base64.sol
@@ -26,7 +26,7 @@ library Base64 {
         // - `data.length + 2`  -> Round up
         // - `/ 3`              -> Number of 3-bytes chunks
         // - `4 *`              -> 4 characters for each chunk
-        uint256 newlength = data.length * 8 / 6;
+        uint256 newlength = (data.length * 8) / 6;
         if (data.length % 6 > 0) {
             newlength++;
         }
@@ -45,7 +45,9 @@ library Base64 {
             for {
                 let dataPtr := data
                 let endPtr := add(data, mload(data))
-            } lt(dataPtr, endPtr) {} {
+            } lt(dataPtr, endPtr) {
+
+            } {
                 // Advance 3 bytes
                 dataPtr := add(dataPtr, 3)
                 let input := mload(dataPtr)