Merge branch 'main' into deploy-factory-create2

src/SsoAccount.sol

@@ -39,16 +39,16 @@ contract SsoAccount is Initializable, HookManager, ERC1271Handler, TokenCallback
 
   /// @notice Initializer function that sets account initial configuration. Expected to be used in the proxy.
   /// @dev Sets passkey and passkey validator within account storage
-  /// @param _initialValidators An array of module validator addresses and initial validation keys
+  /// @param initialValidators An array of module validator addresses and initial validation keys
   /// in an ABI encoded format of `abi.encode(validatorAddr,validationKey))`.
-  /// @param _initialK1Owners An array of addresses with full control over the account.
-  function initialize(bytes[] calldata _initialValidators, address[] calldata _initialK1Owners) external initializer {
-    for (uint256 i = 0; i < _initialValidators.length; ++i) {
-      (address validatorAddr, bytes memory validationKey) = abi.decode(_initialValidators[i], (address, bytes));
+  /// @param initialK1Owners An array of addresses with full control over the account.
+  function initialize(bytes[] calldata initialValidators, address[] calldata initialK1Owners) external initializer {
+    for (uint256 i = 0; i < initialValidators.length; ++i) {
+      (address validatorAddr, bytes memory validationKey) = abi.decode(initialValidators[i], (address, bytes));
       _addModuleValidator(validatorAddr, validationKey);
     }
-    for (uint256 i = 0; i < _initialK1Owners.length; ++i) {
-      _k1AddOwner(_initialK1Owners[i]);
+    for (uint256 i = 0; i < initialK1Owners.length; ++i) {
+      _k1AddOwner(initialK1Owners[i]);
     }
   }
 

src/handlers/ERC1271Handler.sol

@@ -18,26 +18,23 @@ abstract contract ERC1271Handler is IERC1271Upgradeable, EIP712("Sso1271", "1.0.
     bytes32 signedHash;
   }
 
-  bytes32 constant _SSO_MESSAGE_TYPEHASH = keccak256("SsoMessage(bytes32 signedHash)");
+  bytes32 private constant _SSO_MESSAGE_TYPEHASH = keccak256("SsoMessage(bytes32 signedHash)");
 
   bytes4 private constant _ERC1271_MAGIC = 0x1626ba7e;
 
   /**
    * @dev Should return whether the signature provided is valid for the provided data
-   * @param signedHash bytes32                   - Hash of the data that is signed
-   * @param signatureAndValidator bytes calldata - Validator address concatenated to signature
+   * @param hash bytes32 - Hash of the data that is signed
+   * @param signature bytes calldata - Validator address concatenated to signature
    * @return magicValue bytes4 - Magic value if the signature is valid, 0 otherwise
    */
-  function isValidSignature(
-    bytes32 signedHash,
-    bytes memory signatureAndValidator
-  ) public view override returns (bytes4 magicValue) {
-    (bytes memory signature, address validator) = SignatureDecoder.decodeSignatureNoHookData(signatureAndValidator);
+  function isValidSignature(bytes32 hash, bytes memory signature) external view override returns (bytes4 magicValue) {
+    (bytes memory decodedSignature, address validator) = SignatureDecoder.decodeSignatureNoHookData(signature);
 
-    bytes32 eip712Hash = _hashTypedDataV4(_ssoMessageHash(SsoMessage(signedHash)));
+    bytes32 eip712Hash = _hashTypedDataV4(_ssoMessageHash(SsoMessage(hash)));
 
     bool isValid = _isModuleValidator(validator) &&
-      IModuleValidator(validator).validateSignature(eip712Hash, signature);
+      IModuleValidator(validator).validateSignature(eip712Hash, decodedSignature);
 
     magicValue = isValid ? _ERC1271_MAGIC : bytes4(0);
   }
@@ -59,7 +56,7 @@ abstract contract ERC1271Handler is IERC1271Upgradeable, EIP712("Sso1271", "1.0.
     return _SSO_MESSAGE_TYPEHASH;
   }
 
-  function _ssoMessageHash(SsoMessage memory ssoMessage) internal pure returns (bytes32) {
+  function _ssoMessageHash(SsoMessage memory ssoMessage) private pure returns (bytes32) {
     return keccak256(abi.encode(_SSO_MESSAGE_TYPEHASH, ssoMessage.signedHash));
   }
 }

src/handlers/ValidationHandler.sol

@@ -4,7 +4,6 @@ pragma solidity ^0.8.24;
 import { Transaction } from "@matterlabs/zksync-contracts/l2/system-contracts/libraries/TransactionHelper.sol";
 
 import { SignatureDecoder } from "../libraries/SignatureDecoder.sol";
-import { BytesLinkedList } from "../libraries/LinkedList.sol";
 import { OwnerManager } from "../managers/OwnerManager.sol";
 import { ValidatorManager } from "../managers/ValidatorManager.sol";
 

src/helpers/TimestampAsserterLocator.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.24;
 
-import "../interfaces/ITimestampAsserter.sol";
+import { ITimestampAsserter } from "../interfaces/ITimestampAsserter.sol";
 
 library TimestampAsserterLocator {
   function locate() internal view returns (ITimestampAsserter) {

src/helpers/TokenCallbackHandler.sol

@@ -1,8 +1,9 @@
 // SPDX-License-Identifier: GPL-3.0
 pragma solidity ^0.8.24;
-import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
-import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
-import "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
+
+import { IERC165 } from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import { IERC721Receiver } from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
+import { IERC1155Receiver } from "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
 
 /**
  * Token callback handler.

src/libraries/JsmnSolLib.sol

@@ -31,10 +31,10 @@ library JsmnSolLib {
     PRIMITIVE
   }
 
-  uint256 constant RETURN_SUCCESS = 0;
-  uint256 constant RETURN_ERROR_INVALID_JSON = 1;
-  uint256 constant RETURN_ERROR_PART = 2;
-  uint256 constant RETURN_ERROR_NO_MEM = 3;
+  uint256 public constant RETURN_SUCCESS = 0;
+  uint256 public constant RETURN_ERROR_INVALID_JSON = 1;
+  uint256 public constant RETURN_ERROR_PART = 2;
+  uint256 public constant RETURN_ERROR_NO_MEM = 3;
 
   struct Token {
     JsmnType jsmnType;
@@ -57,7 +57,7 @@ library JsmnSolLib {
     return (p, t);
   }
 
-  function allocateToken(Parser memory parser, Token[] memory tokens) internal pure returns (bool, Token memory) {
+  function allocateToken(Parser memory parser, Token[] memory tokens) private pure returns (bool, Token memory) {
     if (parser.toknext >= tokens.length) {
       // no more space in tokens
       return (false, tokens[tokens.length - 1]);
@@ -68,7 +68,7 @@ library JsmnSolLib {
     return (true, token);
   }
 
-  function fillToken(Token memory token, JsmnType jsmnType, uint256 start, uint256 end) internal pure {
+  function fillToken(Token memory token, JsmnType jsmnType, uint256 start, uint256 end) private pure {
     token.jsmnType = jsmnType;
     token.start = start;
     token.startSet = true;
@@ -77,7 +77,7 @@ library JsmnSolLib {
     token.size = 0;
   }
 
-  function parseString(Parser memory parser, Token[] memory tokens, bytes memory s) internal pure returns (uint) {
+  function parseString(Parser memory parser, Token[] memory tokens, bytes memory s) private pure returns (uint) {
     uint256 start = parser.pos;
     bool success;
     Token memory token;
@@ -122,19 +122,23 @@ library JsmnSolLib {
     return RETURN_ERROR_PART;
   }
 
-  function parsePrimitive(Parser memory parser, Token[] memory tokens, bytes memory s) internal pure returns (uint) {
+  function parsePrimitive(Parser memory parser, Token[] memory tokens, bytes memory s) private pure returns (uint) {
     bool found = false;
     uint256 start = parser.pos;
     bool success;
     bytes1 c;
     Token memory token;
+
+    // skip the first character because we assume we've already identified it as a primitive from parse
+    parser.pos++;
+
     for (; parser.pos < s.length; parser.pos++) {
       c = s[parser.pos];
       if (c == " " || c == "\t" || c == "\n" || c == "\r" || c == "," || c == 0x7d || c == 0x5d) {
         found = true;
         break;
       }
-      if (uint8(c) < 32 || uint8(c) > 127) {
+      if (uint8(c) < 32 || uint8(c) >= 127) {
         parser.pos = start;
         return RETURN_ERROR_INVALID_JSON;
       }
@@ -162,15 +166,15 @@ library JsmnSolLib {
     (parser, tokens) = init(numberElements);
 
     // Token memory token;
-    uint256 r;
+    uint256 returnFlag;
     uint256 count = parser.toknext;
     uint256 i;
     Token memory token;
 
     for (; parser.pos < s.length; parser.pos++) {
       bytes1 c = s[parser.pos];
 
-      // 0x7b, 0x5b opening curly parentheses or brackets
+      // 0x7b, 0x5b opening curly braces or square brackets
       if (c == 0x7b || c == 0x5b) {
         count++;
         (success, token) = allocateToken(parser, tokens);
@@ -225,14 +229,13 @@ library JsmnSolLib {
         continue;
       }
 
-      // 0x42
+      // 0x22
       if (c == '"') {
-        r = parseString(parser, tokens, s);
+        returnFlag = parseString(parser, tokens, s);
 
-        if (r != RETURN_SUCCESS) {
-          return (r, tokens, 0);
+        if (returnFlag != RETURN_SUCCESS) {
+          return (returnFlag, tokens, 0);
         }
-        //JsmnError.INVALID;
         count++;
         if (parser.toksuper != -1) tokens[uint(parser.toksuper)].size++;
         continue;
@@ -276,9 +279,9 @@ library JsmnSolLib {
           }
         }
 
-        r = parsePrimitive(parser, tokens, s);
-        if (r != RETURN_SUCCESS) {
-          return (r, tokens, 0);
+        returnFlag = parsePrimitive(parser, tokens, s);
+        if (returnFlag != RETURN_SUCCESS) {
+          return (returnFlag, tokens, 0);
         }
         count++;
         if (parser.toksuper != -1) {
@@ -311,9 +314,8 @@ library JsmnSolLib {
   }
 
   // parseInt(parseFloat*10^_b)
-  function parseInt(string memory _a, uint256 _b) internal pure returns (int) {
+  function parseInt(string memory _a, uint256 _b) internal pure returns (int256 result) {
     bytes memory bresult = bytes(_a);
-    int256 mint = 0;
     bool decimals = false;
     bool negative = false;
     for (uint256 i = 0; i < bresult.length; i++) {
@@ -325,13 +327,13 @@ library JsmnSolLib {
           if (_b == 0) break;
           else _b--;
         }
-        mint *= 10;
-        mint += int(int8(uint8(bresult[i]))) - 48;
+        result *= 10;
+        result += int(int8(uint8(bresult[i]))) - 48;
       } else if (uint8(bresult[i]) == 46) decimals = true;
     }
-    if (_b > 0) mint *= int(10 ** _b);
-    if (negative) mint *= -1;
-    return mint;
+    if (_b > 0) result *= int(10 ** _b);
+    if (negative) result *= -1;
+    return result;
   }
 
   function parseBool(string memory _a) internal pure returns (bool) {