Add Context contracts

contracts/access/access_control/_AccessControl.sol

@@ -6,13 +6,14 @@ import { EnumerableSet } from '../../data/EnumerableSet.sol';
 import { AccessControlStorage } from '../../storage/AccessControlStorage.sol';
 import { AddressUtils } from '../../utils/AddressUtils.sol';
 import { UintUtils } from '../../utils/UintUtils.sol';
+import { _Context } from '../../meta/_Context.sol';
 import { _IAccessControl } from './_IAccessControl.sol';
 
 /**
  * @title Role-based access control system
  * @dev derived from https://github.com/OpenZeppelin/openzeppelin-contracts (MIT license)
  */
-abstract contract _AccessControl is _IAccessControl {
+abstract contract _AccessControl is _IAccessControl, _Context {
     using AddressUtils for address;
     using EnumerableSet for EnumerableSet.AddressSet;
     using UintUtils for uint256;
@@ -45,7 +46,7 @@ abstract contract _AccessControl is _IAccessControl {
      * @param role role to query
      */
     function _checkRole(bytes32 role) internal view virtual {
-        _checkRole(role, msg.sender);
+        _checkRole(role, _msgSender());
     }
 
     /**
@@ -117,7 +118,7 @@ abstract contract _AccessControl is _IAccessControl {
      * @param role role to relinquish
      */
     function _renounceRole(bytes32 role) internal virtual {
-        _setRole(role, msg.sender, false);
+        _setRole(role, _msgSender(), false);
     }
 
     function _setRole(
@@ -131,14 +132,14 @@ abstract contract _AccessControl is _IAccessControl {
                 .roles[role]
                 .members
                 .add(account);
-            emit RoleGranted(role, account, msg.sender);
+            emit RoleGranted(role, account, _msgSender());
         } else {
             AccessControlStorage
                 .layout(AccessControlStorage.DEFAULT_STORAGE_SLOT)
                 .roles[role]
                 .members
                 .remove(account);
-            emit RoleRevoked(role, account, msg.sender);
+            emit RoleRevoked(role, account, _msgSender());
         }
     }
 

contracts/access/access_control/_IAccessControl.sol

@@ -2,10 +2,12 @@
 
 pragma solidity ^0.8.20;
 
+import { _IContext } from '../../meta/_IContext.sol';
+
 /**
  * @title Partial AccessControl interface needed by internal functions
  */
-interface _IAccessControl {
+interface _IAccessControl is _IContext {
     event RoleAdminChanged(
         bytes32 indexed role,
         bytes32 indexed previousAdminRole,

contracts/access/ownable/_IOwnable.sol

@@ -3,8 +3,9 @@
 pragma solidity ^0.8.20;
 
 import { _IERC173 } from '../../interfaces/_IERC173.sol';
+import { _IContext } from '../../meta/_IContext.sol';
 
-interface _IOwnable is _IERC173 {
+interface _IOwnable is _IERC173, _IContext {
     error Ownable__NotOwner();
     error Ownable__NotTransitiveOwner();
 }

contracts/access/ownable/_Ownable.sol

@@ -5,18 +5,19 @@ pragma solidity ^0.8.20;
 import { IERC173 } from '../../interfaces/IERC173.sol';
 import { ERC173Storage } from '../../storage/ERC173Storage.sol';
 import { AddressUtils } from '../../utils/AddressUtils.sol';
+import { _Context } from '../../meta/_Context.sol';
 import { _IOwnable } from './_IOwnable.sol';
 
-abstract contract _Ownable is _IOwnable {
+abstract contract _Ownable is _IOwnable, _Context {
     using AddressUtils for address;
 
     modifier onlyOwner() {
-        if (msg.sender != _owner()) revert Ownable__NotOwner();
+        if (_msgSender() != _owner()) revert Ownable__NotOwner();
         _;
     }
 
     modifier onlyTransitiveOwner() {
-        if (msg.sender != _transitiveOwner())
+        if (_msgSender() != _transitiveOwner())
             revert Ownable__NotTransitiveOwner();
         _;
     }

contracts/access/ownable/_SafeOwnable.sol

@@ -8,7 +8,7 @@ import { _Ownable } from './_Ownable.sol';
 
 abstract contract _SafeOwnable is _ISafeOwnable, _Ownable {
     modifier onlyNomineeOwner() {
-        if (msg.sender != _nomineeOwner())
+        if (_msgSender() != _nomineeOwner())
             revert SafeOwnable__NotNomineeOwner();
         _;
     }
@@ -27,7 +27,7 @@ abstract contract _SafeOwnable is _ISafeOwnable, _Ownable {
      * @notice accept transfer of contract ownership
      */
     function _acceptOwnership() internal virtual onlyNomineeOwner {
-        _setOwner(msg.sender);
+        _setOwner(_msgSender());
         delete ERC173Storage
             .layout(ERC173Storage.DEFAULT_STORAGE_SLOT)
             .nomineeOwner;

contracts/interfaces/IERC2771.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import { _IERC2771 } from './_IERC2771.sol';
+
+/**
+ * @title ERC2771 interface
+ * @dev see https://eips.ethereum.org/EIPS/eip-2771
+ */
+interface IERC2771 is _IERC2771 {
+    /**
+     * @notice query whether account is a trusted ERC2771 forwarder
+     * @param account address to query
+     * @return trustedStatus whether account is a trusted forwarder
+     */
+    function isTrustedForwarder(
+        address account
+    ) external view returns (bool trustedStatus);
+}

contracts/interfaces/_IERC2771.sol

@@ -0,0 +1,5 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+interface _IERC2771 {}

contracts/meta/Context.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import { IContext } from './IContext.sol';
+import { _Context } from './_Context.sol';
+
+abstract contract Context is IContext, _Context {}

contracts/meta/ForwardedMetaTransactionContext.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import { IERC2771 } from '../interfaces/IERC2771.sol';
+import { Context } from './Context.sol';
+import { _Context } from './_Context.sol';
+import { IForwardedMetaTransactionContext } from './IForwardedMetaTransactionContext.sol';
+import { _ForwardedMetaTransactionContext } from './_ForwardedMetaTransactionContext.sol';
+
+abstract contract ForwardedMetaTransactionContext is
+    IForwardedMetaTransactionContext,
+    _ForwardedMetaTransactionContext,
+    Context
+{
+    /**
+     * @inheritdoc IERC2771
+     */
+    function isTrustedForwarder(
+        address account
+    ) external view returns (bool trustedStatus) {
+        trustedStatus = _isTrustedForwarder(account);
+    }
+
+    /**
+     * @inheritdoc _ForwardedMetaTransactionContext
+     */
+    function _msgSender()
+        internal
+        view
+        virtual
+        override(_Context, _ForwardedMetaTransactionContext)
+        returns (address msgSender)
+    {
+        msgSender = super._msgSender();
+    }
+
+    /**
+     * @inheritdoc _ForwardedMetaTransactionContext
+     */
+    function _msgData()
+        internal
+        view
+        virtual
+        override(_Context, _ForwardedMetaTransactionContext)
+        returns (bytes calldata msgData)
+    {
+        msgData = super._msgData();
+    }
+
+    /**
+     * @inheritdoc _ForwardedMetaTransactionContext
+     */
+    function _calldataSuffixLength()
+        internal
+        view
+        virtual
+        override(_Context, _ForwardedMetaTransactionContext)
+        returns (uint256 length)
+    {
+        length = super._calldataSuffixLength();
+    }
+}

contracts/meta/IContext.sol

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import { _IContext } from './_IContext.sol';
+
+interface IContext is _IContext {}

contracts/meta/IForwardedMetaTransactionContext.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import { IERC2771 } from '../interfaces/IERC2771.sol';
+import { IContext } from './IContext.sol';
+import { _IForwardedMetaTransactionContext } from './_IForwardedMetaTransactionContext.sol';
+
+interface IForwardedMetaTransactionContext is
+    _IForwardedMetaTransactionContext,
+    IContext,
+    IERC2771
+{}

contracts/meta/_Context.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import { _IContext } from './_IContext.sol';
+
+/**
+ * @title Utility contract for supporting alternative authorization schemes
+ */
+abstract contract _Context is _IContext {
+    /**
+     * @notice return the message sender
+     * @dev if no Context extension is in use, msg.sender is returned as-is
+     * @return msgSender account contextualized as message sender
+     */
+    function _msgSender() internal view virtual returns (address msgSender) {
+        msgSender = msg.sender;
+    }
+
+    /**
+     * @notice return the message data
+     * @dev if no Context extension is in use, msg.data is returned as-is
+     * @return msgData message data with suffix removed, if applicable
+     */
+    function _msgData() internal view virtual returns (bytes calldata msgData) {
+        msgData = msg.data;
+    }
+
+    /**
+     * @notice return the bytes length of the calldata context suffix
+     * @dev if no Context extension is in use, suffix length is 0
+     * @return length length of calldata context suffix
+     */
+    function _calldataSuffixLength()
+        internal
+        view
+        virtual
+        returns (uint256 length)
+    {
+        length = 0;
+    }
+}

contracts/meta/_ForwardedMetaTransactionContext.sol

@@ -0,0 +1,115 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import { ERC2771Storage } from '../storage/ERC2771Storage.sol';
+import { AddressUtils } from '../utils/AddressUtils.sol';
+import { _Context } from './_Context.sol';
+import { _IForwardedMetaTransactionContext } from './_IForwardedMetaTransactionContext.sol';
+
+abstract contract _ForwardedMetaTransactionContext is
+    _IForwardedMetaTransactionContext,
+    _Context
+{
+    using AddressUtils for address;
+
+    /**
+     * @inheritdoc _Context
+     * @dev sender is read from the calldata context suffix
+     */
+    function _msgSender()
+        internal
+        view
+        virtual
+        override
+        returns (address msgSender)
+    {
+        uint256 dataLength = msg.data.length;
+        uint256 suffixLength = _calldataSuffixLength();
+
+        // ideally this would revert when dataLength < suffixLength and sender is a trusted forwarder
+        // but because _isTrustedForwarder reads from storage, it should be called only when necessary
+
+        if (dataLength >= suffixLength && _isTrustedForwarder(msg.sender)) {
+            unchecked {
+                msgSender = address(
+                    bytes20(msg.data[dataLength - suffixLength:])
+                );
+            }
+        } else {
+            msgSender = super._msgSender();
+        }
+    }
+
+    /**
+     * @inheritdoc _Context
+     */
+    function _msgData()
+        internal
+        view
+        virtual
+        override
+        returns (bytes calldata msgData)
+    {
+        uint256 dataLength = msg.data.length;
+        uint256 suffixLength = _calldataSuffixLength();
+
+        // ideally this would revert when dataLength < suffixLength and sender is a trusted forwarder
+        // but because _isTrustedForwarder reads from storage, it should be called only when necessary
+
+        if (dataLength >= suffixLength && _isTrustedForwarder(msg.sender)) {
+            unchecked {
+                msgData = msg.data[:dataLength - suffixLength];
+            }
+        } else {
+            msgData = super._msgData();
+        }
+    }
+
+    /**
+     * @inheritdoc _Context
+     * @dev this Context extension defines an address suffix with a length of 20
+     */
+    function _calldataSuffixLength()
+        internal
+        view
+        virtual
+        override
+        returns (uint256 length)
+    {
+        length = 20;
+    }
+
+    /**
+     * @notice query whether account is a trusted ERC2771 forwarder
+     * @param account address to query
+     * @return trustedStatus whether account is a trusted forwarder
+     */
+    function _isTrustedForwarder(
+        address account
+    ) internal view virtual returns (bool trustedStatus) {
+        trustedStatus = ERC2771Storage
+            .layout(ERC2771Storage.DEFAULT_STORAGE_SLOT)
+            .trustedForwarders[account];
+    }
+
+    /**
+     * @notice grant trusted forwarder status to account
+     * @param account account whose trusted forwarder status to grant
+     */
+    function _addTrustedForwarder(address account) internal virtual {
+        ERC2771Storage
+            .layout(ERC2771Storage.DEFAULT_STORAGE_SLOT)
+            .trustedForwarders[account] = true;
+    }
+
+    /**
+     * @notice revoke trusted forwarder status from account
+     * @param account account whose trusted forwarder status to revoke
+     */
+    function _removeTrustedForwarder(address account) internal virtual {
+        delete ERC2771Storage
+            .layout(ERC2771Storage.DEFAULT_STORAGE_SLOT)
+            .trustedForwarders[account];
+    }
+}