bump OZ version to 5.5.0-rc.1

contracts/core/BaseUtils.sol

@@ -3,9 +3,10 @@ pragma solidity ^0.8.19;
 
 import { ERC20, OwnerSettings } from "contracts/core/OwnerSettings.sol";
 
-import { ECDSA } from "contracts/lib/utils/ECDSA.sol";
-import { MerkleProofLib as Merkle } from "contracts/lib/utils/MerkleProofLib.sol";
-import { ReentrancyGuard } from "contracts/lib/utils/ReentrancyGuard.sol";
+import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+import { MessageHashUtils } from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";
+import { MerkleProof as Merkle } from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
+import { ReentrancyGuard } from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
 
 abstract contract BaseUtils is
     OwnerSettings,
@@ -43,8 +44,8 @@ abstract contract BaseUtils is
         if (
             !validBacenSigners(
                 _castAddrToKey(
-                    ECDSA.recoverCalldata(
-                        ECDSA.toEthSignedMessageHash(
+                    ECDSA.recover(
+                        MessageHashUtils.toEthSignedMessageHash(
                             _message
                         ),
                         _signature

contracts/core/DataTypes.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.19;
 
-import { ERC20 } from "contracts/lib/tokens/ERC20.sol";
+import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 
 library DataTypes {
 

contracts/core/EventAndErrors.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.19;
 
-import { ERC20 } from "contracts/lib/tokens/ERC20.sol";
+import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 
 // prettier-ignore
 interface EventAndErrors {

contracts/core/OwnerSettings.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.19;
 
-import { ERC2771Context as ERC2771 } from "contracts/lib/metatx/ERC2771Context.sol";
+import { ERC2771 } from "contracts/lib/metatx/ERC2771Context.sol";
 import { ERC20, SafeTransferLib } from "contracts/lib/utils/SafeTransferLib.sol";
 import { IReputation } from "contracts/lib/interfaces/IReputation.sol";
 import { EventAndErrors } from "contracts/core/EventAndErrors.sol";

contracts/lib/metatx/ERC2771Context.sol

@@ -1,87 +1,14 @@
 // SPDX-License-Identifier: MIT
 
-pragma solidity >=0.8.4;
+pragma solidity ^0.8.20;
 
-/// @author OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
-/// (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Context.sol)
+import { ERC2771Context } from "@openzeppelin/contracts/metatx/ERC2771Context.sol";
 
-/// @dev Provides information about the current execution context, including the
-/// sender of the transaction and its data. While these are generally available
-/// via msg.sender and msg.data, they should not be accessed in such a direct
-/// manner, since when dealing with meta-transactions the account sending and
-/// paying for execution may not be the actual sender (as far as an application
-/// is concerned).
-///
-/// This contract is only required for intermediate, library-like contracts.
-abstract contract Context {
-    function _msgSender()
-        internal
-        view
-        virtual
-        returns (address)
-    {
-        return msg.sender;
-    }
-
-    function _msgData()
-        internal
-        view
-        virtual
-        returns (bytes calldata)
-    {
-        return msg.data;
-    }
-}
-
-/// @author Modified from OpenZeppelin Contracts (last updated v4.7.0) (metatx/ERC2771Context.sol)
-/// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/metatx/ERC2771Context.sol
-
-/// @dev Context variant with ERC2771 support.
-abstract contract ERC2771Context is Context {
-    // address private immutable _trustedForwarder;
+abstract contract ERC2771 is ERC2771Context(address(0)) {
     mapping(address => bool) public trustedForwarders;
-
-    /// @custom:oz-upgrades-unsafe-allow constructor
-    // constructor(address trustedForwarder) {
-    //     _trustedForwarder = trustedForwarder;
-    // }
-
-    function _msgSender()
-        internal
-        view
-        virtual
-        override
-        returns (address sender)
-    {
-        if (trustedForwarders[msg.sender]) {
-            // The assembly code is more direct than the Solidity version using `abi.decode`.
-            /// @solidity memory-safe-assembly
-            assembly {
-                sender := shr(
-                    96,
-                    calldataload(sub(calldatasize(), 20))
-                )
-            }
-        } else {
-            return super._msgSender();
-        }
-    }
-
-    function isTrustedForwarder(address forwarder) public view virtual returns (bool) {
+    
+    function isTrustedForwarder(address forwarder) public view override returns (bool) {
       return trustedForwarders[forwarder];
     }
 
-    function _msgData()
-        internal
-        view
-        virtual
-        override
-        returns (bytes calldata)
-    {
-        if (isTrustedForwarder(msg.sender)) {
-            return msg.data[:msg.data.length - 20];
-        } else {
-            return super._msgData();
-        }
-    }
 }

contracts/lib/mock/mockToken.sol

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.19;
 
-import { ERC20 } from "../tokens/ERC20.sol";
+import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 
 contract MockToken is ERC20 {
-    constructor(uint256 supply) ERC20("MockBRL", "MBRL", 18) {
+    constructor(uint256 supply) ERC20("MockBRL", "MBRL") {
         _mint(msg.sender, supply);
     }
 

contracts/lib/tokens/ERC20.sol

@@ -1,250 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity >=0.8.4;
-
-/// @notice Modern and gas efficient ERC20 + EIP-2612 implementation.
-/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC20.sol)
-/// @author Modified from Uniswap (https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol)
-/// @dev Do not manually set balances without updating totalSupply, as the sum of all user balances must not exceed it.
-abstract contract ERC20 {
-    /*//////////////////////////////////////////////////////////////
-                                 EVENTS
-    //////////////////////////////////////////////////////////////*/
-
-    event Transfer(
-        address indexed from,
-        address indexed to,
-        uint256 amount
-    );
-
-    event Approval(
-        address indexed owner,
-        address indexed spender,
-        uint256 amount
-    );
-
-    /*//////////////////////////////////////////////////////////////
-                            METADATA STORAGE
-    //////////////////////////////////////////////////////////////*/
-
-    string public name;
-
-    string public symbol;
-
-    uint8 public immutable decimals;
-
-    /*//////////////////////////////////////////////////////////////
-                              ERC20 STORAGE
-    //////////////////////////////////////////////////////////////*/
-
-    uint256 public totalSupply;
-
-    mapping(address => uint256) public balanceOf;
-
-    mapping(address => mapping(address => uint256))
-        public allowance;
-
-    /*//////////////////////////////////////////////////////////////
-                            EIP-2612 STORAGE
-    //////////////////////////////////////////////////////////////*/
-
-    uint256 internal immutable INITIAL_CHAIN_ID;
-
-    bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;
-
-    mapping(address => uint256) public nonces;
-
-    /*//////////////////////////////////////////////////////////////
-                               CONSTRUCTOR
-    //////////////////////////////////////////////////////////////*/
-
-    constructor(
-        string memory _name,
-        string memory _symbol,
-        uint8 _decimals
-    ) {
-        name = _name;
-        symbol = _symbol;
-        decimals = _decimals;
-
-        INITIAL_CHAIN_ID = block.chainid;
-        INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();
-    }
-
-    /*//////////////////////////////////////////////////////////////
-                               ERC20 LOGIC
-    //////////////////////////////////////////////////////////////*/
-
-    function approve(
-        address spender,
-        uint256 amount
-    ) public virtual returns (bool) {
-        allowance[msg.sender][spender] = amount;
-
-        emit Approval(msg.sender, spender, amount);
-
-        return true;
-    }
-
-    function transfer(
-        address to,
-        uint256 amount
-    ) public virtual returns (bool) {
-        balanceOf[msg.sender] -= amount;
-
-        // Cannot overflow because the sum of all user
-        // balances can't exceed the max uint256 value.
-        unchecked {
-            balanceOf[to] += amount;
-        }
-
-        emit Transfer(msg.sender, to, amount);
-
-        return true;
-    }
-
-    function transferFrom(
-        address from,
-        address to,
-        uint256 amount
-    ) public virtual returns (bool) {
-        uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals.
-
-        if (allowed != type(uint256).max)
-            allowance[from][msg.sender] = allowed - amount;
-
-        balanceOf[from] -= amount;
-
-        // Cannot overflow because the sum of all user
-        // balances can't exceed the max uint256 value.
-        unchecked {
-            balanceOf[to] += amount;
-        }
-
-        emit Transfer(from, to, amount);
-
-        return true;
-    }
-
-    /*//////////////////////////////////////////////////////////////
-                             EIP-2612 LOGIC
-    //////////////////////////////////////////////////////////////*/
-
-    function permit(
-        address owner,
-        address spender,
-        uint256 value,
-        uint256 deadline,
-        uint8 v,
-        bytes32 r,
-        bytes32 s
-    ) public virtual {
-        require(
-            deadline >= block.timestamp,
-            "PERMIT_DEADLINE_EXPIRED"
-        );
-
-        // Unchecked because the only math done is incrementing
-        // the owner's nonce which cannot realistically overflow.
-        unchecked {
-            address recoveredAddress = ecrecover(
-                keccak256(
-                    abi.encodePacked(
-                        "\x19\x01",
-                        DOMAIN_SEPARATOR(),
-                        keccak256(
-                            abi.encode(
-                                keccak256(
-                                    "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
-                                ),
-                                owner,
-                                spender,
-                                value,
-                                nonces[owner]++,
-                                deadline
-                            )
-                        )
-                    )
-                ),
-                v,
-                r,
-                s
-            );
-
-            require(
-                recoveredAddress != address(0) &&
-                    recoveredAddress == owner,
-                "INVALID_SIGNER"
-            );
-
-            allowance[recoveredAddress][spender] = value;
-        }
-
-        emit Approval(owner, spender, value);
-    }
-
-    function DOMAIN_SEPARATOR()
-        public
-        view
-        virtual
-        returns (bytes32)
-    {
-        return
-            block.chainid == INITIAL_CHAIN_ID
-                ? INITIAL_DOMAIN_SEPARATOR
-                : computeDomainSeparator();
-    }
-
-    function computeDomainSeparator()
-        internal
-        view
-        virtual
-        returns (bytes32)
-    {
-        return
-            keccak256(
-                abi.encode(
-                    keccak256(
-                        "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
-                    ),
-                    keccak256(bytes(name)),
-                    keccak256("1"),
-                    block.chainid,
-                    address(this)
-                )
-            );
-    }
-
-    /*//////////////////////////////////////////////////////////////
-                        INTERNAL MINT/BURN LOGIC
-    //////////////////////////////////////////////////////////////*/
-
-    function _mint(
-        address to,
-        uint256 amount
-    ) internal virtual {
-        totalSupply += amount;
-
-        // Cannot overflow because the sum of all user
-        // balances can't exceed the max uint256 value.
-        unchecked {
-            balanceOf[to] += amount;
-        }
-
-        emit Transfer(address(0), to, amount);
-    }
-
-    function _burn(
-        address from,
-        uint256 amount
-    ) internal virtual {
-        balanceOf[from] -= amount;
-
-        // Cannot underflow because a user's balance
-        // will never be larger than the total supply.
-        unchecked {
-            totalSupply -= amount;
-        }
-
-        emit Transfer(from, address(0), amount);
-    }
-}

contracts/lib/utils/ECDSA.sol

@@ -1,95 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity >=0.8.4;
-
-/// @notice Gas optimized ECDSA wrapper.
-/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/ECDSA.sol)
-/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/ECDSA.sol)
-/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/ECDSA.sol)
-library ECDSA {
-    /// @dev The signature is invalid.
-    error InvalidSignature();
-
-    /// @dev The number which `s` must not exceed in order for
-    /// the signature to be non-malleable.
-    bytes32 private constant _MALLEABILITY_THRESHOLD =
-        0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0;
-
-    /// @dev Recovers the signer's address from a message digest `hash`,
-    /// and the `signature`.
-    ///
-    /// This function does NOT accept EIP-2098 short form signatures.
-    /// Use `recover(bytes32 hash, bytes32 r, bytes32 vs)` for EIP-2098
-    /// short form signatures instead.
-    function recoverCalldata(
-        bytes32 hash,
-        bytes calldata signature
-    ) internal view returns (address result) {
-        /// @solidity memory-safe-assembly
-        assembly {
-            // Copy the free memory pointer so that we can restore it later.
-            let m := mload(0x40)
-            // Directly copy `r` and `s` from the calldata.
-            calldatacopy(0x40, signature.offset, 0x40)
-            // Store the `hash` in the scratch space.
-            mstore(0x00, hash)
-            // Compute `v` and store it in the scratch space.
-            mstore(
-                0x20,
-                byte(
-                    0,
-                    calldataload(add(signature.offset, 0x40))
-                )
-            )
-            pop(
-                staticcall(
-                    gas(), // Amount of gas left for the transaction.
-                    and(
-                        // If the signature is exactly 65 bytes in length.
-                        eq(signature.length, 65),
-                        // If `s` in lower half order, such that the signature is not malleable.
-                        lt(
-                            mload(0x60),
-                            add(_MALLEABILITY_THRESHOLD, 1)
-                        )
-                    ), // Address of `ecrecover`.
-                    0x00, // Start of input.
-                    0x80, // Size of input.
-                    0x00, // Start of output.
-                    0x20 // Size of output.
-                )
-            )
-            result := mload(0x00)
-            // `returndatasize()` will be `0x20` upon success, and `0x00` otherwise.
-            if iszero(returndatasize()) {
-                // Store the function selector of `InvalidSignature()`.
-                mstore(0x00, 0x8baa579f)
-                // Revert with (offset, size).
-                revert(0x1c, 0x04)
-            }
-            // Restore the zero slot.
-            mstore(0x60, 0)
-            // Restore the free memory pointer.
-            mstore(0x40, m)
-        }
-    }
-
-    /// @dev Returns an Ethereum Signed Message, created from a `hash`.
-    /// This produces a hash corresponding to the one signed with the
-    /// [`eth_sign`](https://eth.wiki/json-rpc/API#eth_sign)
-    /// JSON-RPC method as part of EIP-191.
-    function toEthSignedMessageHash(
-        bytes32 hash
-    ) internal pure returns (bytes32 result) {
-        /// @solidity memory-safe-assembly
-        assembly {
-            // Store into scratch space for keccak256.
-            mstore(0x20, hash)
-            mstore(
-                0x00,
-                "\x00\x00\x00\x00\x19Ethereum Signed Message:\n32"
-            )
-            // 0x40 - 0x04 = 0x3c
-            result := keccak256(0x04, 0x3c)
-        }
-    }
-}

contracts/lib/utils/MerkleProofLib.sol

@@ -1,58 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity >=0.8.4;
-
-/// @notice Gas optimized verification of proof of inclusion for a leaf in a Merkle tree.
-/// @author Solady
-/// (https://github.com/vectorized/solady/blob/main/src/utils/MerkleProofLib.sol)
-/// @author Modified from Solmate
-/// (https://github.com/transmissions11/solmate/blob/main/src/utils/MerkleProofLib.sol)
-/// @author Modified from OpenZeppelin
-/// (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/MerkleProof.sol)
-library MerkleProofLib {
-    /// @dev Returns whether `leaf` exists in the Merkle tree with `root`, given `proof`.
-    function verify(
-        bytes32[] calldata proof,
-        bytes32 root,
-        bytes32 leaf
-    ) internal pure returns (bool isValid) {
-        /// @solidity memory-safe-assembly
-        assembly {
-            if proof.length {
-                // Left shift by 5 is equivalent to multiplying by 0x20.
-                let end := add(
-                    proof.offset,
-                    shl(5, proof.length)
-                )
-                // Initialize `offset` to the offset of `proof` in the calldata.
-                let offset := proof.offset
-                // Iterate over proof elements to compute root hash.
-                for {
-
-                } 1 {
-
-                } {
-                    // Slot of `leaf` in scratch space.
-                    // If the condition is true: 0x20, otherwise: 0x00.
-                    let scratch := shl(
-                        5,
-                        gt(leaf, calldataload(offset))
-                    )
-                    // Store elements to hash contiguously in scratch space.
-                    // Scratch space is 64 bytes (0x00 - 0x3f) and both elements are 32 bytes.
-                    mstore(scratch, leaf)
-                    mstore(
-                        xor(scratch, 0x20),
-                        calldataload(offset)
-                    )
-                    // Reuse `leaf` to store the hash to reduce stack operations.
-                    leaf := keccak256(0x00, 0x40)
-                    offset := add(offset, 0x20)
-                    if iszero(lt(offset, end)) {
-                        break
-                    }
-                }
-            }
-            isValid := eq(leaf, root)
-        }
-    }
-}

contracts/lib/utils/ReentrancyGuard.sol

@@ -1,34 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity >=0.8.4;
-
-/// @notice Reentrancy protection for smart contracts.
-/// @author z0r0z.eth
-/// @author Modified from Seaport
-///         (https://github.com/ProjectOpenSea/seaport/blob/main/contracts/lib/ReentrancyGuard.sol)
-/// @author Modified from Solmate
-///         (https://github.com/Rari-Capital/solmate/blob/main/src/utils/ReentrancyGuard.sol)
-abstract contract ReentrancyGuard {
-    error Reentrancy();
-
-    uint256 private guard = 1;
-
-    modifier nonReentrant() virtual {
-        setReentrancyGuard();
-
-        _;
-
-        clearReentrancyGuard();
-    }
-
-    /// @dev Check guard sentinel value and set it.
-    function setReentrancyGuard() internal virtual {
-        if (guard == 2) revert Reentrancy();
-
-        guard = 2;
-    }
-
-    /// @dev Unset sentinel value.
-    function clearReentrancyGuard() internal virtual {
-        guard = 1;
-    }
-}

contracts/lib/utils/SafeTransferLib.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity >=0.8.4;
 
-import { ERC20 } from "../tokens/ERC20.sol";
+import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 
 /// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.
 /// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/SafeTransferLib.sol)

package.json

@@ -38,6 +38,7 @@
     "@nomicfoundation/hardhat-verify": "^2.1.0",
     "@nomicfoundation/hardhat-viem": "^2.1.0",
     "@nomicfoundation/ignition-core": "^0.15.13",
+    "@openzeppelin/contracts": "^5.5.0-rc.1",
     "@typechain/ethers-v6": "^0.5.1",
     "@typechain/hardhat": "^9.1.0",
     "@types/chai": "^4.3.20",

yarn.lock

@@ -988,6 +988,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@openzeppelin/contracts@npm:^5.5.0-rc.1":
+  version: 5.5.0-rc.1
+  resolution: "@openzeppelin/contracts@npm:5.5.0-rc.1"
+  checksum: 10/f8dc5fc2b5ce55c193aeda1913983c3af6fd1b7905be7fcaaf02e782e1cc3f8d9c430d74c958513bc23e336169ff0c8ab44bbefb20d7e4acbe90603d4169776b
+  languageName: node
+  linkType: hard
+
 "@pkgjs/parseargs@npm:^0.11.0":
   version: 0.11.0
   resolution: "@pkgjs/parseargs@npm:0.11.0"
@@ -4563,6 +4570,7 @@ __metadata:
     "@nomicfoundation/hardhat-verify": "npm:^2.1.0"
     "@nomicfoundation/hardhat-viem": "npm:^2.1.0"
     "@nomicfoundation/ignition-core": "npm:^0.15.13"
+    "@openzeppelin/contracts": "npm:^5.5.0-rc.1"
     "@typechain/ethers-v6": "npm:^0.5.1"
     "@typechain/hardhat": "npm:^9.1.0"
     "@types/chai": "npm:^4.3.20"