@rarible/external-contracts 3.11.4

package/contracts/extension/plugin/Router.sol

@@ -0,0 +1,270 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import "../interface/plugin/IRouter.sol";
+import "../Multicall.sol";
+import "../../eip/ERC165.sol";
+import "../../external-deps/openzeppelin/utils/EnumerableSet.sol";
+
+/**
+ *  @author  thirdweb.com
+ */
+library RouterStorage {
+    /// @custom:storage-location erc7201:router.storage
+    /// @dev keccak256(abi.encode(uint256(keccak256("router.storage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 public constant ROUTER_STORAGE_POSITION =
+        0x012ef321094c8c682aa635dfdfcd754624a7473f08ad6ac415bb7f35eb12a100;
+
+    struct Data {
+        EnumerableSet.Bytes32Set allSelectors;
+        mapping(address => EnumerableSet.Bytes32Set) selectorsForPlugin;
+        mapping(bytes4 => IPluginMap.Plugin) pluginForSelector;
+    }
+
+    function routerStorage() internal pure returns (Data storage routerData) {
+        bytes32 position = ROUTER_STORAGE_POSITION;
+        assembly {
+            routerData.slot := position
+        }
+    }
+}
+
+abstract contract Router is Multicall, ERC165, IRouter {
+    using EnumerableSet for EnumerableSet.Bytes32Set;
+    /*///////////////////////////////////////////////////////////////
+                            State variables
+    //////////////////////////////////////////////////////////////*/
+
+    address public immutable pluginMap;
+
+    /*///////////////////////////////////////////////////////////////
+                    Constructor + initializer logic
+    //////////////////////////////////////////////////////////////*/
+
+    constructor(address _pluginMap) {
+        pluginMap = _pluginMap;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                                ERC 165
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {IERC165-supportsInterface}.
+     */
+    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
+        return interfaceId == type(IRouter).interfaceId || super.supportsInterface(interfaceId);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                        Generic contract logic
+    //////////////////////////////////////////////////////////////*/
+
+    fallback() external payable virtual {
+        address _pluginAddress = _getPluginForFunction(msg.sig);
+        if (_pluginAddress == address(0)) {
+            _pluginAddress = IPluginMap(pluginMap).getPluginForFunction(msg.sig);
+        }
+        _delegate(_pluginAddress);
+    }
+
+    receive() external payable {}
+
+    function _delegate(address implementation) internal virtual {
+        assembly {
+            // Copy msg.data. We take full control of memory in this inline assembly
+            // block because it will not return to Solidity code. We overwrite the
+            // Solidity scratch pad at memory position 0.
+            calldatacopy(0, 0, calldatasize())
+
+            // Call the implementation.
+            // out and outsize are 0 because we don't know the size yet.
+            let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
+
+            // Copy the returned data.
+            returndatacopy(0, 0, returndatasize())
+
+            switch result
+            // delegatecall returns 0 on error.
+            case 0 {
+                revert(0, returndatasize())
+            }
+            default {
+                return(0, returndatasize())
+            }
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                        External functions
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev Add functionality to the contract.
+    function addPlugin(Plugin memory _plugin) external {
+        require(_canSetPlugin(), "Router: Not authorized");
+
+        _addPlugin(_plugin);
+    }
+
+    /// @dev Update or override existing functionality.
+    function updatePlugin(Plugin memory _plugin) external {
+        require(_canSetPlugin(), "Map: Not authorized");
+
+        _updatePlugin(_plugin);
+    }
+
+    /// @dev Remove existing functionality from the contract.
+    function removePlugin(bytes4 _selector) external {
+        require(_canSetPlugin(), "Map: Not authorized");
+
+        _removePlugin(_selector);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                            View functions
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev View address of the plugged-in functionality contract for a given function signature.
+    function getPluginForFunction(bytes4 _selector) public view returns (address) {
+        address pluginAddress = _getPluginForFunction(_selector);
+
+        return pluginAddress != address(0) ? pluginAddress : IPluginMap(pluginMap).getPluginForFunction(_selector);
+    }
+
+    /// @dev View all funtionality as list of function signatures.
+    function getAllFunctionsOfPlugin(address _pluginAddress) external view returns (bytes4[] memory registered) {
+        RouterStorage.Data storage data = RouterStorage.routerStorage();
+
+        EnumerableSet.Bytes32Set storage selectorsForPlugin = data.selectorsForPlugin[_pluginAddress];
+        bytes4[] memory defaultSelectors = IPluginMap(pluginMap).getAllFunctionsOfPlugin(_pluginAddress);
+
+        uint256 len = defaultSelectors.length;
+        uint256 count = selectorsForPlugin.length() + defaultSelectors.length;
+
+        for (uint256 i = 0; i < len; i += 1) {
+            if (selectorsForPlugin.contains(defaultSelectors[i])) {
+                count -= 1;
+                defaultSelectors[i] = bytes4(0);
+            }
+        }
+
+        registered = new bytes4[](count);
+        uint256 index;
+
+        for (uint256 i = 0; i < len; i += 1) {
+            if (defaultSelectors[i] != bytes4(0)) {
+                registered[index++] = defaultSelectors[i];
+            }
+        }
+
+        len = selectorsForPlugin.length();
+        for (uint256 i = 0; i < len; i += 1) {
+            registered[index++] = bytes4(data.selectorsForPlugin[_pluginAddress].at(i));
+        }
+    }
+
+    /// @dev View all funtionality existing on the contract.
+    function getAllPlugins() external view returns (Plugin[] memory registered) {
+        RouterStorage.Data storage data = RouterStorage.routerStorage();
+
+        EnumerableSet.Bytes32Set storage overrideSelectors = data.allSelectors;
+        Plugin[] memory defaultPlugins = IPluginMap(pluginMap).getAllPlugins();
+
+        uint256 overrideSelectorsLen = overrideSelectors.length();
+        uint256 defaultPluginsLen = defaultPlugins.length;
+
+        uint256 totalCount = overrideSelectorsLen + defaultPluginsLen;
+
+        for (uint256 i = 0; i < overrideSelectorsLen; i += 1) {
+            for (uint256 j = 0; j < defaultPluginsLen; j += 1) {
+                if (bytes4(overrideSelectors.at(i)) == defaultPlugins[j].functionSelector) {
+                    totalCount -= 1;
+                    defaultPlugins[j].functionSelector = bytes4(0);
+                }
+            }
+        }
+
+        registered = new Plugin[](totalCount);
+        uint256 index;
+
+        for (uint256 i = 0; i < defaultPluginsLen; i += 1) {
+            if (defaultPlugins[i].functionSelector != bytes4(0)) {
+                registered[index] = defaultPlugins[i];
+                index += 1;
+            }
+        }
+
+        for (uint256 i = 0; i < overrideSelectorsLen; i += 1) {
+            registered[index] = data.pluginForSelector[bytes4(overrideSelectors.at(i))];
+            index += 1;
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                        Internal functions
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev View address of the plugged-in functionality contract for a given function signature.
+    function _getPluginForFunction(bytes4 _selector) public view returns (address) {
+        RouterStorage.Data storage data = RouterStorage.routerStorage();
+        address _pluginAddress = data.pluginForSelector[_selector].pluginAddress;
+
+        return _pluginAddress;
+    }
+
+    /// @dev Add functionality to the contract.
+    function _addPlugin(Plugin memory _plugin) internal {
+        RouterStorage.Data storage data = RouterStorage.routerStorage();
+
+        // Revert: default plugin exists for function; use updatePlugin instead.
+        try IPluginMap(pluginMap).getPluginForFunction(_plugin.functionSelector) returns (address) {
+            revert("Router: default plugin exists for function.");
+        } catch {
+            require(data.allSelectors.add(bytes32(_plugin.functionSelector)), "Router: plugin exists for function.");
+        }
+
+        require(
+            _plugin.functionSelector == bytes4(keccak256(abi.encodePacked(_plugin.functionSignature))),
+            "Router: fn selector and signature mismatch."
+        );
+
+        data.pluginForSelector[_plugin.functionSelector] = _plugin;
+        data.selectorsForPlugin[_plugin.pluginAddress].add(bytes32(_plugin.functionSelector));
+
+        emit PluginAdded(_plugin.functionSelector, _plugin.pluginAddress);
+    }
+
+    /// @dev Update or override existing functionality.
+    function _updatePlugin(Plugin memory _plugin) internal {
+        address currentPlugin = getPluginForFunction(_plugin.functionSelector);
+        require(
+            _plugin.functionSelector == bytes4(keccak256(abi.encodePacked(_plugin.functionSignature))),
+            "Router: fn selector and signature mismatch."
+        );
+
+        RouterStorage.Data storage data = RouterStorage.routerStorage();
+        data.allSelectors.add(bytes32(_plugin.functionSelector));
+        data.pluginForSelector[_plugin.functionSelector] = _plugin;
+        data.selectorsForPlugin[currentPlugin].remove(bytes32(_plugin.functionSelector));
+        data.selectorsForPlugin[_plugin.pluginAddress].add(bytes32(_plugin.functionSelector));
+
+        emit PluginUpdated(_plugin.functionSelector, currentPlugin, _plugin.pluginAddress);
+    }
+
+    /// @dev Remove existing functionality from the contract.
+    function _removePlugin(bytes4 _selector) internal {
+        RouterStorage.Data storage data = RouterStorage.routerStorage();
+        address currentPlugin = _getPluginForFunction(_selector);
+        require(currentPlugin != address(0), "Router: No plugin available for selector");
+
+        delete data.pluginForSelector[_selector];
+        data.allSelectors.remove(_selector);
+        data.selectorsForPlugin[currentPlugin].remove(bytes32(_selector));
+
+        emit PluginRemoved(_selector, currentPlugin);
+    }
+
+    function _canSetPlugin() internal view virtual returns (bool);
+}

package/contracts/extension/plugin/RouterImmutable.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import "./Router.sol";
+
+/**
+ *  @author  thirdweb.com
+ */
+contract RouterImmutable is Router {
+    /*///////////////////////////////////////////////////////////////
+                    Constructor + initializer logic
+    //////////////////////////////////////////////////////////////*/
+
+    constructor(address _pluginMap) Router(_pluginMap) {}
+
+    /*///////////////////////////////////////////////////////////////
+                        Internal functions
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev Returns whether plug-in can be set in the given execution context.
+    function _canSetPlugin() internal pure override returns (bool) {
+        return false;
+    }
+}

package/contracts/extension/plugin/RoyaltyPayments.sol

@@ -0,0 +1,121 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import "../interface/IRoyaltyPayments.sol";
+import "../interface/IRoyaltyEngineV1.sol";
+import { IERC2981 } from "../../eip/interface/IERC2981.sol";
+
+library RoyaltyPaymentsStorage {
+    /// @custom:storage-location erc7201:royalty.payments.storage
+    /// @dev keccak256(abi.encode(uint256(keccak256("royalty.payments.storage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 public constant ROYALTY_PAYMENTS_STORAGE_POSITION =
+        0xc802b338f3fb784853cf3c808df5ff08335200e394ea2c687d12571a91045000;
+
+    struct Data {
+        /// @dev The address of RoyaltyEngineV1, replacing the one set during construction.
+        address royaltyEngineAddressOverride;
+    }
+
+    function royaltyPaymentsStorage() internal pure returns (Data storage royaltyPaymentsData) {
+        bytes32 position = ROYALTY_PAYMENTS_STORAGE_POSITION;
+        assembly {
+            royaltyPaymentsData.slot := position
+        }
+    }
+}
+
+/**
+ *  @author  thirdweb.com
+ *
+ *  @title   Royalty Payments
+ *  @notice  Thirdweb's `RoyaltyPayments` is a contract extension to be used with a marketplace contract.
+ *           It exposes functions for fetching royalty settings for a token.
+ *           It Supports RoyaltyEngineV1 and RoyaltyRegistry by manifold.xyz.
+ */
+
+abstract contract RoyaltyPaymentsLogic is IRoyaltyPayments {
+    // solhint-disable-next-line var-name-mixedcase
+    address immutable ROYALTY_ENGINE_ADDRESS;
+
+    constructor(address _royaltyEngineAddress) {
+        // allow address(0) in case RoyaltyEngineV1 not present on a network
+        require(
+            _royaltyEngineAddress == address(0) ||
+                IERC165(_royaltyEngineAddress).supportsInterface(type(IRoyaltyEngineV1).interfaceId),
+            "Doesn't support IRoyaltyEngineV1 interface"
+        );
+
+        ROYALTY_ENGINE_ADDRESS = _royaltyEngineAddress;
+    }
+
+    /**
+     * Get the royalty for a given token (address, id) and value amount.  Does not cache the bps/amounts.  Caches the spec for a given token address
+     *
+     * @param tokenAddress - The address of the token
+     * @param tokenId      - The id of the token
+     * @param value        - The value you wish to get the royalty of
+     *
+     * returns Two arrays of equal length, royalty recipients and the corresponding amount each recipient should get
+     */
+    function getRoyalty(
+        address tokenAddress,
+        uint256 tokenId,
+        uint256 value
+    ) external returns (address payable[] memory recipients, uint256[] memory amounts) {
+        address royaltyEngineAddress = getRoyaltyEngineAddress();
+
+        if (royaltyEngineAddress == address(0)) {
+            try IERC2981(tokenAddress).royaltyInfo(tokenId, value) returns (address recipient, uint256 amount) {
+                require(amount < value, "Invalid royalty amount");
+
+                recipients = new address payable[](1);
+                amounts = new uint256[](1);
+                recipients[0] = payable(recipient);
+                amounts[0] = amount;
+            } catch {}
+        } else {
+            (recipients, amounts) = IRoyaltyEngineV1(royaltyEngineAddress).getRoyalty(tokenAddress, tokenId, value);
+        }
+    }
+
+    /**
+     * Set or override RoyaltyEngine address
+     *
+     * @param _royaltyEngineAddress - RoyaltyEngineV1 address
+     */
+    function setRoyaltyEngine(address _royaltyEngineAddress) external {
+        if (!_canSetRoyaltyEngine()) {
+            revert("Not authorized");
+        }
+
+        require(
+            _royaltyEngineAddress != address(0) &&
+                IERC165(_royaltyEngineAddress).supportsInterface(type(IRoyaltyEngineV1).interfaceId),
+            "Doesn't support IRoyaltyEngineV1 interface"
+        );
+
+        _setupRoyaltyEngine(_royaltyEngineAddress);
+    }
+
+    /// @dev Returns original or overridden address for RoyaltyEngineV1
+    function getRoyaltyEngineAddress() public view returns (address royaltyEngineAddress) {
+        RoyaltyPaymentsStorage.Data storage data = RoyaltyPaymentsStorage.royaltyPaymentsStorage();
+        address royaltyEngineOverride = data.royaltyEngineAddressOverride;
+        royaltyEngineAddress = royaltyEngineOverride != address(0) ? royaltyEngineOverride : ROYALTY_ENGINE_ADDRESS;
+    }
+
+    /// @dev Lets a contract admin update the royalty engine address
+    function _setupRoyaltyEngine(address _royaltyEngineAddress) internal {
+        RoyaltyPaymentsStorage.Data storage data = RoyaltyPaymentsStorage.royaltyPaymentsStorage();
+        address currentAddress = data.royaltyEngineAddressOverride;
+
+        data.royaltyEngineAddressOverride = _royaltyEngineAddress;
+
+        emit RoyaltyEngineUpdated(currentAddress, _royaltyEngineAddress);
+    }
+
+    /// @dev Returns whether royalty engine address can be set in the given execution context.
+    function _canSetRoyaltyEngine() internal view virtual returns (bool);
+}

package/contracts/extension/upgradeable/AccountPermissions.sol

@@ -0,0 +1,253 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import "../interface/IAccountPermissions.sol";
+import "../../external-deps/openzeppelin/utils/cryptography/EIP712.sol";
+import "../../external-deps/openzeppelin/utils/structs/EnumerableSet.sol";
+
+library AccountPermissionsStorage {
+    /// @custom:storage-location erc7201:account.permissions.storage
+    /// @dev keccak256(abi.encode(uint256(keccak256("account.permissions.storage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 public constant ACCOUNT_PERMISSIONS_STORAGE_POSITION =
+        0x3181e78fc1b109bc611fd2406150bf06e33faa75f71cba12c3e1fd670f2def00;
+
+    struct Data {
+        /// @dev The set of all admins of the wallet.
+        EnumerableSet.AddressSet allAdmins;
+        /// @dev The set of all signers with permission to use the account.
+        EnumerableSet.AddressSet allSigners;
+        /// @dev Map from address => whether the address is an admin.
+        mapping(address => bool) isAdmin;
+        /// @dev Map from signer address => active restrictions for that signer.
+        mapping(address => IAccountPermissions.SignerPermissionsStatic) signerPermissions;
+        /// @dev Map from signer address => approved target the signer can call using the account contract.
+        mapping(address => EnumerableSet.AddressSet) approvedTargets;
+        /// @dev Mapping from a signed request UID => whether the request is processed.
+        mapping(bytes32 => bool) executed;
+    }
+
+    function data() internal pure returns (Data storage data_) {
+        bytes32 position = ACCOUNT_PERMISSIONS_STORAGE_POSITION;
+        assembly {
+            data_.slot := position
+        }
+    }
+}
+
+abstract contract AccountPermissions is IAccountPermissions, EIP712 {
+    using ECDSA for bytes32;
+    using EnumerableSet for EnumerableSet.AddressSet;
+
+    bytes32 private constant TYPEHASH =
+        keccak256(
+            "SignerPermissionRequest(address signer,uint8 isAdmin,address[] approvedTargets,uint256 nativeTokenLimitPerTransaction,uint128 permissionStartTimestamp,uint128 permissionEndTimestamp,uint128 reqValidityStartTimestamp,uint128 reqValidityEndTimestamp,bytes32 uid)"
+        );
+
+    function _onlyAdmin() internal virtual {
+        require(isAdmin(msg.sender), "!admin");
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                            External functions
+    //////////////////////////////////////////////////////////////*/
+
+    /// @notice Sets the permissions for a given signer.
+    function setPermissionsForSigner(SignerPermissionRequest calldata _req, bytes calldata _signature) external {
+        address targetSigner = _req.signer;
+
+        require(
+            _req.reqValidityStartTimestamp <= block.timestamp && block.timestamp < _req.reqValidityEndTimestamp,
+            "!period"
+        );
+
+        (bool success, address signer) = verifySignerPermissionRequest(_req, _signature);
+        require(success, "!sig");
+
+        _accountPermissionsStorage().executed[_req.uid] = true;
+
+        //isAdmin > 0, set admin or remove admin
+        if (_req.isAdmin > 0) {
+            //isAdmin = 1, set admin
+            //isAdmin > 1, remove admin
+            bool _isAdmin = _req.isAdmin == 1;
+
+            _setAdmin(targetSigner, _isAdmin);
+            return;
+        }
+
+        require(!isAdmin(targetSigner), "admin");
+
+        _accountPermissionsStorage().allSigners.add(targetSigner);
+
+        _accountPermissionsStorage().signerPermissions[targetSigner] = SignerPermissionsStatic(
+            _req.nativeTokenLimitPerTransaction,
+            _req.permissionStartTimestamp,
+            _req.permissionEndTimestamp
+        );
+
+        address[] memory currentTargets = _accountPermissionsStorage().approvedTargets[targetSigner].values();
+        uint256 len = currentTargets.length;
+
+        for (uint256 i = 0; i < len; i += 1) {
+            _accountPermissionsStorage().approvedTargets[targetSigner].remove(currentTargets[i]);
+        }
+
+        len = _req.approvedTargets.length;
+        for (uint256 i = 0; i < len; i += 1) {
+            _accountPermissionsStorage().approvedTargets[targetSigner].add(_req.approvedTargets[i]);
+        }
+
+        _afterSignerPermissionsUpdate(_req);
+
+        emit SignerPermissionsUpdated(signer, targetSigner, _req);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                            View functions
+    //////////////////////////////////////////////////////////////*/
+
+    /// @notice Returns whether the given account is an admin.
+    function isAdmin(address _account) public view virtual returns (bool) {
+        return _accountPermissionsStorage().isAdmin[_account];
+    }
+
+    /// @notice Returns whether the given account is an active signer on the account.
+    function isActiveSigner(address signer) public view returns (bool) {
+        SignerPermissionsStatic memory permissions = _accountPermissionsStorage().signerPermissions[signer];
+
+        return
+            permissions.startTimestamp <= block.timestamp &&
+            block.timestamp < permissions.endTimestamp &&
+            _accountPermissionsStorage().approvedTargets[signer].length() > 0;
+    }
+
+    /// @notice Returns the restrictions under which a signer can use the smart wallet.
+    function getPermissionsForSigner(address signer) external view returns (SignerPermissions memory) {
+        SignerPermissionsStatic memory permissions = _accountPermissionsStorage().signerPermissions[signer];
+
+        return
+            SignerPermissions(
+                signer,
+                _accountPermissionsStorage().approvedTargets[signer].values(),
+                permissions.nativeTokenLimitPerTransaction,
+                permissions.startTimestamp,
+                permissions.endTimestamp
+            );
+    }
+
+    /// @dev Verifies that a request is signed by an authorized account.
+    function verifySignerPermissionRequest(
+        SignerPermissionRequest calldata req,
+        bytes calldata signature
+    ) public view virtual returns (bool success, address signer) {
+        signer = _recoverAddress(_encodeRequest(req), signature);
+        success = !_accountPermissionsStorage().executed[req.uid] && isAdmin(signer);
+    }
+
+    /// @notice Returns all active and inactive signers of the account.
+    function getAllSigners() external view returns (SignerPermissions[] memory signers) {
+        address[] memory allSigners = _accountPermissionsStorage().allSigners.values();
+
+        uint256 len = allSigners.length;
+        signers = new SignerPermissions[](len);
+        for (uint256 i = 0; i < len; i += 1) {
+            address signer = allSigners[i];
+            SignerPermissionsStatic memory permissions = _accountPermissionsStorage().signerPermissions[signer];
+
+            signers[i] = SignerPermissions(
+                signer,
+                _accountPermissionsStorage().approvedTargets[signer].values(),
+                permissions.nativeTokenLimitPerTransaction,
+                permissions.startTimestamp,
+                permissions.endTimestamp
+            );
+        }
+    }
+
+    /// @notice Returns all signers with active permissions to use the account.
+    function getAllActiveSigners() external view returns (SignerPermissions[] memory signers) {
+        address[] memory allSigners = _accountPermissionsStorage().allSigners.values();
+
+        uint256 len = allSigners.length;
+        uint256 numOfActiveSigners = 0;
+
+        for (uint256 i = 0; i < len; i += 1) {
+            if (isActiveSigner(allSigners[i])) {
+                numOfActiveSigners++;
+            } else {
+                allSigners[i] = address(0);
+            }
+        }
+
+        signers = new SignerPermissions[](numOfActiveSigners);
+        uint256 index = 0;
+        for (uint256 i = 0; i < len; i += 1) {
+            if (allSigners[i] != address(0)) {
+                address signer = allSigners[i];
+                SignerPermissionsStatic memory permissions = _accountPermissionsStorage().signerPermissions[signer];
+
+                signers[index++] = SignerPermissions(
+                    signer,
+                    _accountPermissionsStorage().approvedTargets[signer].values(),
+                    permissions.nativeTokenLimitPerTransaction,
+                    permissions.startTimestamp,
+                    permissions.endTimestamp
+                );
+            }
+        }
+    }
+
+    /// @notice Returns all admins of the account.
+    function getAllAdmins() external view returns (address[] memory) {
+        return _accountPermissionsStorage().allAdmins.values();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                        Internal functions
+    //////////////////////////////////////////////////////////////*/
+
+    /// @notice Runs after every `changeRole` run.
+    function _afterSignerPermissionsUpdate(SignerPermissionRequest calldata _req) internal virtual;
+
+    /// @notice Makes the given account an admin.
+    function _setAdmin(address _account, bool _isAdmin) internal virtual {
+        _accountPermissionsStorage().isAdmin[_account] = _isAdmin;
+
+        if (_isAdmin) {
+            _accountPermissionsStorage().allAdmins.add(_account);
+        } else {
+            _accountPermissionsStorage().allAdmins.remove(_account);
+        }
+
+        emit AdminUpdated(_account, _isAdmin);
+    }
+
+    /// @dev Returns the address of the signer of the request.
+    function _recoverAddress(bytes memory _encoded, bytes calldata _signature) internal view virtual returns (address) {
+        return _hashTypedDataV4(keccak256(_encoded)).recover(_signature);
+    }
+
+    /// @dev Encodes a request for recovery of the signer in `recoverAddress`.
+    function _encodeRequest(SignerPermissionRequest calldata _req) internal pure virtual returns (bytes memory) {
+        return
+            abi.encode(
+                TYPEHASH,
+                _req.signer,
+                _req.isAdmin,
+                keccak256(abi.encodePacked(_req.approvedTargets)),
+                _req.nativeTokenLimitPerTransaction,
+                _req.permissionStartTimestamp,
+                _req.permissionEndTimestamp,
+                _req.reqValidityStartTimestamp,
+                _req.reqValidityEndTimestamp,
+                _req.uid
+            );
+    }
+
+    /// @dev Returns the AccountPermissions storage.
+    function _accountPermissionsStorage() internal pure returns (AccountPermissionsStorage.Data storage data) {
+        data = AccountPermissionsStorage.data();
+    }
+}