diff --git a/deployments/goerli/.chainId b/deployments/goerli/.chainId deleted file mode 100644 index 7813681f..00000000 --- a/deployments/goerli/.chainId +++ /dev/null @@ -1 +0,0 @@ -5 \ No newline at end of file diff --git a/deployments/goerli/GnosisWrapper.json b/deployments/goerli/GnosisWrapper.json deleted file mode 100644 index 60ca0100..00000000 --- a/deployments/goerli/GnosisWrapper.json +++ /dev/null @@ -1,381 +0,0 @@ -{ - "address": "0xE7eBEa7c81890B893EC352D1e85FE8055d7d6AB8", - "abi": [ - { - "inputs": [], - "name": "NotAuthorized", - "type": "error" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": false, - "internalType": "address", - "name": "previousAdmin", - "type": "address" - }, - { - "indexed": false, - "internalType": "address", - "name": "newAdmin", - "type": "address" - } - ], - "name": "AdminChanged", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": true, - "internalType": "address", - "name": "beacon", - "type": "address" - } - ], - "name": "BeaconUpgraded", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": false, - "internalType": "uint8", - "name": "version", - "type": "uint8" - } - ], - "name": "Initialized", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": true, - "internalType": "address", - "name": "implementation", - "type": "address" - } - ], - "name": "Upgraded", - "type": "event" - }, - { - "inputs": [], - "name": "accessControl", - "outputs": [ - { - "internalType": "contract IDAOAccessControl", - "name": "", - "type": "address" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [], - "name": "gnosisSafe", - "outputs": [ - { - "internalType": "address", - "name": "", - "type": "address" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "_accessControl", - "type": "address" - }, - { - "internalType": "address", - "name": "_gnosisSafe", - "type": "address" - } - ], - "name": "initialize", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [], - "name": "moduleFactory", - "outputs": [ - { - "internalType": "address", - "name": "", - "type": "address" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [], - "name": "name", - "outputs": [ - { - "internalType": "string", - "name": "", - "type": "string" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [], - "name": "proxiableUUID", - "outputs": [ - { - "internalType": "bytes32", - "name": "", - "type": "bytes32" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "bytes4", - "name": "interfaceId", - "type": "bytes4" - } - ], - "name": "supportsInterface", - "outputs": [ - { - "internalType": "bool", - "name": "", - "type": "bool" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "newImplementation", - "type": "address" - } - ], - "name": "upgradeTo", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "newImplementation", - "type": "address" - }, - { - "internalType": "bytes", - "name": "data", - "type": "bytes" - } - ], - "name": "upgradeToAndCall", - "outputs": [], - "stateMutability": "payable", - "type": "function" - } - ], - "transactionHash": "0x570d3efee4f3d7561d27eaead29583bf28af701ee98e5f84127ba5f9911ff356", - "receipt": { - "to": null, - "from": "0x346658f99924B8Cfe8b6A2418070192385848CA9", - "contractAddress": "0xE7eBEa7c81890B893EC352D1e85FE8055d7d6AB8", - "transactionIndex": 82, - "gasUsed": "949574", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", - "blockHash": "0x2316a60173b75492f16b66c15d1459e1e5984cc18d631d9e7f17117950aef428", - "transactionHash": "0x570d3efee4f3d7561d27eaead29583bf28af701ee98e5f84127ba5f9911ff356", - "logs": [], - "blockNumber": 7416094, - "cumulativeGasUsed": "13070410", - "status": 1, - "byzantium": true - }, - "args": [], - "numDeployments": 1, - "solcInputHash": "32801c180c72a260c0a67f69b3ec7a05", - "metadata": "{\"compiler\":{\"version\":\"0.8.13+commit.abaa5c0e\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"NotAuthorized\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"accessControl\",\"outputs\":[{\"internalType\":\"contract IDAOAccessControl\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"gnosisSafe\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_accessControl\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_gnosisSafe\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"moduleFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"name()\":{\"returns\":{\"_0\":\"The module name\"}},\"proxiableUUID()\":{\"details\":\"Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the implementation. It is used to validate that the this implementation remains valid after an upgrade. IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.\"},\"supportsInterface(bytes4)\":{\"details\":\"See {IERC165-supportsInterface}.\"},\"upgradeTo(address)\":{\"details\":\"Upgrade the implementation of the proxy to `newImplementation`. Calls {_authorizeUpgrade}. Emits an {Upgraded} event.\"},\"upgradeToAndCall(address,bytes)\":{\"details\":\"Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call encoded in `data`. Calls {_authorizeUpgrade}. Emits an {Upgraded} event.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"name()\":{\"notice\":\"Returns the module name\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/GnosisWrapper.sol\":\"GnosisWrapper\"},\"evmVersion\":\"london\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@fractal-framework/core-contracts/contracts/ModuleBase.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\\\";\\r\\nimport \\\"@openzeppelin/contracts/utils/introspection/ERC165Storage.sol\\\";\\r\\nimport \\\"./interfaces/IModuleBase.sol\\\";\\r\\n\\r\\n/// @notice An abstract contract to be inherited by module contracts\\r\\nabstract contract ModuleBase is IModuleBase, UUPSUpgradeable, ERC165Storage {\\r\\n IDAOAccessControl public accessControl;\\r\\n address public moduleFactory;\\r\\n string internal _name;\\r\\n\\r\\n /// @notice Requires that a function caller has the associated role\\r\\n modifier authorized() {\\r\\n if (\\r\\n !accessControl.actionIsAuthorized(\\r\\n msg.sender,\\r\\n address(this),\\r\\n msg.sig\\r\\n )\\r\\n ) {\\r\\n revert NotAuthorized();\\r\\n }\\r\\n _;\\r\\n }\\r\\n\\r\\n /// @notice Function for initializing the contract that can only be called once\\r\\n /// @param _accessControl The address of the access control contract\\r\\n /// @param _moduleFactory The address of the factory deploying the module\\r\\n /// @param __name Human readable string of the module name\\r\\n function __initBase(address _accessControl, address _moduleFactory, string memory __name)\\r\\n internal\\r\\n onlyInitializing\\r\\n {\\r\\n accessControl = IDAOAccessControl(_accessControl);\\r\\n moduleFactory = _moduleFactory;\\r\\n _name = __name;\\r\\n __UUPSUpgradeable_init();\\r\\n _registerInterface(type(IModuleBase).interfaceId);\\r\\n }\\r\\n\\r\\n /// @dev Applies authorized modifier so that an upgrade require the caller to have the correct role\\r\\n /// @param newImplementation The address of the new implementation contract being upgraded to\\r\\n function _authorizeUpgrade(address newImplementation)\\r\\n internal\\r\\n override\\r\\n authorized\\r\\n {}\\r\\n\\r\\n /// @notice Returns the module name\\r\\n /// @return The module name\\r\\n function name() public view virtual returns (string memory) {\\r\\n return _name;\\r\\n }\\r\\n}\\r\\n\",\"keccak256\":\"0xdd4b440c6924fe479e6e3c72e35d109c3af3a9eeb72eab85c65bbe31a2b05dcf\",\"license\":\"Unlicense\"},\"@fractal-framework/core-contracts/contracts/interfaces/IDAOAccessControl.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\ninterface IDAOAccessControl {\\r\\n struct RoleData {\\r\\n mapping(address => bool) members;\\r\\n string adminRole;\\r\\n }\\r\\n\\r\\n error UnequalArrayLengths();\\r\\n error MissingRole(address account, string role);\\r\\n error OnlySelfRenounce();\\r\\n\\r\\n event ActionRoleAdded(\\r\\n address target,\\r\\n string functionDesc,\\r\\n bytes4 encodedSig,\\r\\n string role\\r\\n );\\r\\n event ActionRoleRemoved(\\r\\n address target,\\r\\n string functionDesc,\\r\\n bytes4 encodedSig,\\r\\n string role\\r\\n );\\r\\n event RoleAdminChanged(\\r\\n string role,\\r\\n string previousAdminRole,\\r\\n string adminRole\\r\\n );\\r\\n event RoleGranted(string role, address account, address admin);\\r\\n event RoleRevoked(string role, address account, address admin);\\r\\n\\r\\n /// @notice Initialize DAO action and role permissions\\r\\n /// @param dao Address to receive DAO role\\r\\n /// @param roles What permissions are assigned to\\r\\n /// @param roleAdmins Roles which have the ability to remove or add members\\r\\n /// @param members Addresses to be granted the specified roles\\r\\n /// @param targets Contract addresses for actions to be defined on\\r\\n /// @param functionDescs Function descriptions used to define actions\\r\\n /// @param actionRoles Roles being granted permission for an action\\r\\n function initialize(\\r\\n address dao,\\r\\n string[] memory roles,\\r\\n string[] memory roleAdmins,\\r\\n address[][] memory members,\\r\\n address[] memory targets,\\r\\n string[] memory functionDescs,\\r\\n string[][] memory actionRoles\\r\\n ) external;\\r\\n\\r\\n /// @notice Grants roles to the specified addresses and defines admin roles\\r\\n /// @notice This function can only be called by the DAO\\r\\n /// @param roles The roles being granted\\r\\n /// @param roleAdmins The roles being granted as admins of the specified of roles\\r\\n /// @param members Addresses being granted each specified role\\r\\n function daoGrantRolesAndAdmins(\\r\\n string[] memory roles,\\r\\n string[] memory roleAdmins,\\r\\n address[][] memory members\\r\\n ) external;\\r\\n\\r\\n /// @notice Grants roles to the specified addresses\\r\\n /// @notice This function can only be called by the DAO\\r\\n /// @param roles The roles being granted\\r\\n /// @param members Addresses being granted each specified role\\r\\n function daoGrantRoles(string[] memory roles, address[][] memory members)\\r\\n external;\\r\\n\\r\\n /// @notice Authorizes roles to execute the specified actions\\r\\n /// @notice This function can only be called by the DAO\\r\\n /// @param targets The contract addresses that the action functions are implemented on\\r\\n /// @param functionDescs The function descriptions used to define the actions\\r\\n /// @param roles Roles being granted permission for an action\\r\\n function daoAddActionsRoles(\\r\\n address[] memory targets,\\r\\n string[] memory functionDescs,\\r\\n string[][] memory roles\\r\\n ) external;\\r\\n\\r\\n /// @notice Removes autorization for roles to execute the specified actions\\r\\n /// @notice This function can only be called by the DAO\\r\\n /// @param targets The contract addresses that the action functions are implemented on\\r\\n /// @param functionDescs The function description used to define the actions\\r\\n /// @param roles Roles that action permissions are being removed on\\r\\n function daoRemoveActionsRoles(\\r\\n address[] memory targets,\\r\\n string[] memory functionDescs,\\r\\n string[][] memory roles\\r\\n ) external;\\r\\n\\r\\n /// @notice Grants a role to the specified address\\r\\n /// @notice This function can only be called by an admin of the specified role\\r\\n /// @param role The role being granted\\r\\n /// @param account The address being granted the specified role\\r\\n function adminGrantRole(string memory role, address account)\\r\\n external;\\r\\n\\r\\n /// @notice Revokes a role from the specified address\\r\\n /// @notice This function can only be called by an admin of the specified role\\r\\n /// @param role The role being revoked\\r\\n /// @param account The address the role is being revoked from\\r\\n function adminRevokeRole(string memory role, address account)\\r\\n external;\\r\\n\\r\\n /// @notice Enables an address to remove one of its own roles\\r\\n /// @notice This function can only be called by the account specified\\r\\n /// @param role The role being renounced\\r\\n /// @param account The address renouncing the role\\r\\n function userRenounceRole(string memory role, address account) external;\\r\\n\\r\\n /// @notice Checks if a caller has the permissions to execute the specific action\\r\\n /// @param caller Address attempting to execute the action\\r\\n /// @param target Contract address corresponding to the action\\r\\n /// @param sig The function signature used to define the action\\r\\n function actionIsAuthorized(\\r\\n address caller,\\r\\n address target,\\r\\n bytes4 sig\\r\\n ) external view returns (bool isAuthorized);\\r\\n\\r\\n /// @notice Returns the roles autorized to execute the specified action\\r\\n /// @param target Contract address corresponding to the action\\r\\n /// @param functionDesc The function description used to define the action\\r\\n function getActionRoles(address target, string memory functionDesc)\\r\\n external\\r\\n view\\r\\n returns (string[] memory roles);\\r\\n\\r\\n /// @notice Checks if a specific role is authorized for an action\\r\\n /// @param role Role that authorization is being checked on\\r\\n /// @param target Contract address corresponding to the action\\r\\n /// @param functionDesc Function description used to define the action\\r\\n /// @return isAuthorized Indicates whether the role is authorized to execute the action\\r\\n function isRoleAuthorized(\\r\\n string calldata role,\\r\\n address target,\\r\\n string memory functionDesc\\r\\n ) external view returns (bool isAuthorized);\\r\\n\\r\\n /// @notice Returns whether the account has been granted the role\\r\\n /// @param role Role that authorization is being checked on\\r\\n /// @param account Address that the role authorization is being check on\\r\\n /// @return boolean Indicates whether the address has been granted the role\\r\\n function hasRole(string memory role, address account)\\r\\n external\\r\\n view\\r\\n returns (bool);\\r\\n\\r\\n /// @notice Returns the role that is the admin of the specified role\\r\\n /// @param role Role that the admin role is being returned for\\r\\n /// @return string The admin role of the specified role\\r\\n function getRoleAdmin(string memory role)\\r\\n external\\r\\n view\\r\\n returns (string memory);\\r\\n\\r\\n /// @return string The string \\\"DAO_ROLE\\\"\\r\\n function DAO_ROLE() external view returns (string memory);\\r\\n}\\r\\n\",\"keccak256\":\"0x8862f578b4fe6a79370b5cbe896e59df4722e95dbb1b0d2e286e335915ed616c\",\"license\":\"Unlicense\"},\"@fractal-framework/core-contracts/contracts/interfaces/IModuleBase.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\nimport \\\"./IDAOAccessControl.sol\\\";\\r\\n\\r\\ninterface IModuleBase {\\r\\n error NotAuthorized();\\r\\n\\r\\n /// @return IDAOAccessControl The Access control interface\\r\\n function accessControl() external view returns (IDAOAccessControl);\\r\\n\\r\\n /// @return string The string \\\"Name\\\"\\r\\n function name() external view returns (string memory);\\r\\n}\\r\\n\",\"keccak256\":\"0xf7aa0a6fc64e3ea68e1fe799390408e62bfd9d1339d6c31c6d862f3af158cca6\",\"license\":\"Unlicense\"},\"@openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified\\n * proxy whose upgrades are fully controlled by the current implementation.\\n */\\ninterface IERC1822ProxiableUpgradeable {\\n /**\\n * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation\\n * address.\\n *\\n * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\\n * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\\n * function revert if invoked through a proxy.\\n */\\n function proxiableUUID() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0x77c89f893e403efc6929ba842b7ccf6534d4ffe03afe31670b4a528c0ad78c0f\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/ERC1967/ERC1967UpgradeUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../beacon/IBeaconUpgradeable.sol\\\";\\nimport \\\"../../interfaces/draft-IERC1822Upgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/StorageSlotUpgradeable.sol\\\";\\nimport \\\"../utils/Initializable.sol\\\";\\n\\n/**\\n * @dev This abstract contract provides getters and event emitting update functions for\\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.\\n *\\n * _Available since v4.1._\\n *\\n * @custom:oz-upgrades-unsafe-allow delegatecall\\n */\\nabstract contract ERC1967UpgradeUpgradeable is Initializable {\\n function __ERC1967Upgrade_init() internal onlyInitializing {\\n }\\n\\n function __ERC1967Upgrade_init_unchained() internal onlyInitializing {\\n }\\n // This is the keccak-256 hash of \\\"eip1967.proxy.rollback\\\" subtracted by 1\\n bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;\\n\\n /**\\n * @dev Storage slot with the address of the current implementation.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.implementation\\\" subtracted by 1, and is\\n * validated in the constructor.\\n */\\n bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n /**\\n * @dev Emitted when the implementation is upgraded.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function _getImplementation() internal view returns (address) {\\n return StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new address in the EIP1967 implementation slot.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(AddressUpgradeable.isContract(newImplementation), \\\"ERC1967: new implementation is not a contract\\\");\\n StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\\n }\\n\\n /**\\n * @dev Perform implementation upgrade\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeTo(address newImplementation) internal {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Perform implementation upgrade with additional setup call.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeToAndCall(\\n address newImplementation,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n _upgradeTo(newImplementation);\\n if (data.length > 0 || forceCall) {\\n _functionDelegateCall(newImplementation, data);\\n }\\n }\\n\\n /**\\n * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeToAndCallUUPS(\\n address newImplementation,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n // Upgrades from old implementations will perform a rollback test. This test requires the new\\n // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing\\n // this special case will break upgrade paths from old UUPS implementation to new ones.\\n if (StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT).value) {\\n _setImplementation(newImplementation);\\n } else {\\n try IERC1822ProxiableUpgradeable(newImplementation).proxiableUUID() returns (bytes32 slot) {\\n require(slot == _IMPLEMENTATION_SLOT, \\\"ERC1967Upgrade: unsupported proxiableUUID\\\");\\n } catch {\\n revert(\\\"ERC1967Upgrade: new implementation is not UUPS\\\");\\n }\\n _upgradeToAndCall(newImplementation, data, forceCall);\\n }\\n }\\n\\n /**\\n * @dev Storage slot with the admin of the contract.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.admin\\\" subtracted by 1, and is\\n * validated in the constructor.\\n */\\n bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\\n\\n /**\\n * @dev Emitted when the admin account has changed.\\n */\\n event AdminChanged(address previousAdmin, address newAdmin);\\n\\n /**\\n * @dev Returns the current admin.\\n */\\n function _getAdmin() internal view returns (address) {\\n return StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new address in the EIP1967 admin slot.\\n */\\n function _setAdmin(address newAdmin) private {\\n require(newAdmin != address(0), \\\"ERC1967: new admin is the zero address\\\");\\n StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value = newAdmin;\\n }\\n\\n /**\\n * @dev Changes the admin of the proxy.\\n *\\n * Emits an {AdminChanged} event.\\n */\\n function _changeAdmin(address newAdmin) internal {\\n emit AdminChanged(_getAdmin(), newAdmin);\\n _setAdmin(newAdmin);\\n }\\n\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Emitted when the beacon is upgraded.\\n */\\n event BeaconUpgraded(address indexed beacon);\\n\\n /**\\n * @dev Returns the current beacon.\\n */\\n function _getBeacon() internal view returns (address) {\\n return StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new beacon in the EIP1967 beacon slot.\\n */\\n function _setBeacon(address newBeacon) private {\\n require(AddressUpgradeable.isContract(newBeacon), \\\"ERC1967: new beacon is not a contract\\\");\\n require(\\n AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()),\\n \\\"ERC1967: beacon implementation is not a contract\\\"\\n );\\n StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value = newBeacon;\\n }\\n\\n /**\\n * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does\\n * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).\\n *\\n * Emits a {BeaconUpgraded} event.\\n */\\n function _upgradeBeaconToAndCall(\\n address newBeacon,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n _setBeacon(newBeacon);\\n emit BeaconUpgraded(newBeacon);\\n if (data.length > 0 || forceCall) {\\n _functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data);\\n }\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function _functionDelegateCall(address target, bytes memory data) private returns (bytes memory) {\\n require(AddressUpgradeable.isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return AddressUpgradeable.verifyCallResult(success, returndata, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x315887e846f1e5f8d8fa535a229d318bb9290aaa69485117f1ee8a9a6b3be823\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/beacon/IBeaconUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeaconUpgradeable {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x24b86ac8c005b8c654fbf6ac34a5a4f61580d7273541e83e013e89d66fbf0908\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\\n * reused. This mechanism prevents re-execution of each \\\"step\\\" but allows the creation of new initialization steps in\\n * case an upgrade adds a module that needs to be initialized.\\n *\\n * For example:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * contract MyToken is ERC20Upgradeable {\\n * function initialize() initializer public {\\n * __ERC20_init(\\\"MyToken\\\", \\\"MTK\\\");\\n * }\\n * }\\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\\n * function initializeV2() reinitializer(2) public {\\n * __ERC20Permit_init(\\\"MyToken\\\");\\n * }\\n * }\\n * ```\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n *\\n * [CAUTION]\\n * ====\\n * Avoid leaving a contract uninitialized.\\n *\\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * /// @custom:oz-upgrades-unsafe-allow constructor\\n * constructor() {\\n * _disableInitializers();\\n * }\\n * ```\\n * ====\\n */\\nabstract contract Initializable {\\n /**\\n * @dev Indicates that the contract has been initialized.\\n * @custom:oz-retyped-from bool\\n */\\n uint8 private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Triggered when the contract has been initialized or reinitialized.\\n */\\n event Initialized(uint8 version);\\n\\n /**\\n * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\\n * `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`.\\n */\\n modifier initializer() {\\n bool isTopLevelCall = !_initializing;\\n require(\\n (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\\n \\\"Initializable: contract is already initialized\\\"\\n );\\n _initialized = 1;\\n if (isTopLevelCall) {\\n _initializing = true;\\n }\\n _;\\n if (isTopLevelCall) {\\n _initializing = false;\\n emit Initialized(1);\\n }\\n }\\n\\n /**\\n * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\\n * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\\n * used to initialize parent contracts.\\n *\\n * `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original\\n * initialization step. This is essential to configure modules that are added through upgrades and that require\\n * initialization.\\n *\\n * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\\n * a contract, executing them in the right order is up to the developer or operator.\\n */\\n modifier reinitializer(uint8 version) {\\n require(!_initializing && _initialized < version, \\\"Initializable: contract is already initialized\\\");\\n _initialized = version;\\n _initializing = true;\\n _;\\n _initializing = false;\\n emit Initialized(version);\\n }\\n\\n /**\\n * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\\n * {initializer} and {reinitializer} modifiers, directly or indirectly.\\n */\\n modifier onlyInitializing() {\\n require(_initializing, \\\"Initializable: contract is not initializing\\\");\\n _;\\n }\\n\\n /**\\n * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\\n * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\\n * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\\n * through proxies.\\n */\\n function _disableInitializers() internal virtual {\\n require(!_initializing, \\\"Initializable: contract is initializing\\\");\\n if (_initialized < type(uint8).max) {\\n _initialized = type(uint8).max;\\n emit Initialized(type(uint8).max);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0203dcadc5737d9ef2c211d6fa15d18ebc3b30dfa51903b64870b01a062b0b4e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (proxy/utils/UUPSUpgradeable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../interfaces/draft-IERC1822Upgradeable.sol\\\";\\nimport \\\"../ERC1967/ERC1967UpgradeUpgradeable.sol\\\";\\nimport \\\"./Initializable.sol\\\";\\n\\n/**\\n * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an\\n * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.\\n *\\n * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is\\n * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing\\n * `UUPSUpgradeable` with a custom implementation of upgrades.\\n *\\n * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.\\n *\\n * _Available since v4.1._\\n */\\nabstract contract UUPSUpgradeable is Initializable, IERC1822ProxiableUpgradeable, ERC1967UpgradeUpgradeable {\\n function __UUPSUpgradeable_init() internal onlyInitializing {\\n }\\n\\n function __UUPSUpgradeable_init_unchained() internal onlyInitializing {\\n }\\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment\\n address private immutable __self = address(this);\\n\\n /**\\n * @dev Check that the execution is being performed through a delegatecall call and that the execution context is\\n * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case\\n * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a\\n * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to\\n * fail.\\n */\\n modifier onlyProxy() {\\n require(address(this) != __self, \\\"Function must be called through delegatecall\\\");\\n require(_getImplementation() == __self, \\\"Function must be called through active proxy\\\");\\n _;\\n }\\n\\n /**\\n * @dev Check that the execution is not being performed through a delegate call. This allows a function to be\\n * callable on the implementing contract but not through proxies.\\n */\\n modifier notDelegated() {\\n require(address(this) == __self, \\\"UUPSUpgradeable: must not be called through delegatecall\\\");\\n _;\\n }\\n\\n /**\\n * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the\\n * implementation. It is used to validate that the this implementation remains valid after an upgrade.\\n *\\n * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\\n * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\\n * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.\\n */\\n function proxiableUUID() external view virtual override notDelegated returns (bytes32) {\\n return _IMPLEMENTATION_SLOT;\\n }\\n\\n /**\\n * @dev Upgrade the implementation of the proxy to `newImplementation`.\\n *\\n * Calls {_authorizeUpgrade}.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function upgradeTo(address newImplementation) external virtual onlyProxy {\\n _authorizeUpgrade(newImplementation);\\n _upgradeToAndCallUUPS(newImplementation, new bytes(0), false);\\n }\\n\\n /**\\n * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call\\n * encoded in `data`.\\n *\\n * Calls {_authorizeUpgrade}.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function upgradeToAndCall(address newImplementation, bytes memory data) external payable virtual onlyProxy {\\n _authorizeUpgrade(newImplementation);\\n _upgradeToAndCallUUPS(newImplementation, data, true);\\n }\\n\\n /**\\n * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by\\n * {upgradeTo} and {upgradeToAndCall}.\\n *\\n * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.\\n *\\n * ```solidity\\n * function _authorizeUpgrade(address) internal override onlyOwner {}\\n * ```\\n */\\n function _authorizeUpgrade(address newImplementation) internal virtual;\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x6e36e9b4b71de699c2f3f0d4e4d1aa0b35da99a26e8d5b91ef09ba234b4ef270\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x611aa3f23e59cfdd1863c536776407b3e33d695152a266fa7cfb34440a29a8a3\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StorageSlotUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for reading and writing primitive types to specific storage slots.\\n *\\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\\n * This library helps with reading and writing to such slots without the need for inline assembly.\\n *\\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\\n *\\n * Example usage to set ERC1967 implementation slot:\\n * ```\\n * contract ERC1967 {\\n * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n *\\n * function _getImplementation() internal view returns (address) {\\n * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\\n * }\\n *\\n * function _setImplementation(address newImplementation) internal {\\n * require(Address.isContract(newImplementation), \\\"ERC1967: new implementation is not a contract\\\");\\n * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\\n * }\\n * }\\n * ```\\n *\\n * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._\\n */\\nlibrary StorageSlotUpgradeable {\\n struct AddressSlot {\\n address value;\\n }\\n\\n struct BooleanSlot {\\n bool value;\\n }\\n\\n struct Bytes32Slot {\\n bytes32 value;\\n }\\n\\n struct Uint256Slot {\\n uint256 value;\\n }\\n\\n /**\\n * @dev Returns an `AddressSlot` with member `value` located at `slot`.\\n */\\n function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\\n */\\n function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\\n */\\n function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\\n */\\n function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n}\\n\",\"keccak256\":\"0x09864aea84f01e39313375b5610c73a3c1c68abbdc51e5ccdd25ff977fdadf9a\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/ERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165 is IERC165 {\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165).interfaceId;\\n }\\n}\\n\",\"keccak256\":\"0xd10975de010d89fd1c78dc5e8a9a7e7f496198085c151648f20cba166b32582b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/ERC165Storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165Storage.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./ERC165.sol\\\";\\n\\n/**\\n * @dev Storage based implementation of the {IERC165} interface.\\n *\\n * Contracts may inherit from this and call {_registerInterface} to declare\\n * their support of an interface.\\n */\\nabstract contract ERC165Storage is ERC165 {\\n /**\\n * @dev Mapping of interface ids to whether or not it's supported.\\n */\\n mapping(bytes4 => bool) private _supportedInterfaces;\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return super.supportsInterface(interfaceId) || _supportedInterfaces[interfaceId];\\n }\\n\\n /**\\n * @dev Registers the contract as an implementer of the interface defined by\\n * `interfaceId`. Support of the actual ERC165 interface is automatic and\\n * registering its interface id is not required.\\n *\\n * See {IERC165-supportsInterface}.\\n *\\n * Requirements:\\n *\\n * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).\\n */\\n function _registerInterface(bytes4 interfaceId) internal virtual {\\n require(interfaceId != 0xffffffff, \\\"ERC165: invalid interface id\\\");\\n _supportedInterfaces[interfaceId] = true;\\n }\\n}\\n\",\"keccak256\":\"0x77bf0086774bab931413c3388d3a0f7d44cf6878965b72147f57bb0fbbf394bd\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x447a5f3ddc18419d41ff92b3773fb86471b1db25773e07f877f548918a185bf1\",\"license\":\"MIT\"},\"contracts/GnosisWrapper.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\nimport \\\"@fractal-framework/core-contracts/contracts/ModuleBase.sol\\\";\\r\\nimport \\\"./IGnosisWrapper.sol\\\";\\r\\n\\r\\ncontract GnosisWrapper is ModuleBase {\\r\\n address public gnosisSafe;\\r\\n\\r\\n function initialize(address _accessControl, address _gnosisSafe)\\r\\n public\\r\\n initializer\\r\\n {\\r\\n __initBase(_accessControl, msg.sender, \\\"Wrapper Module\\\");\\r\\n _registerInterface(type(IGnosisWrapper).interfaceId);\\r\\n gnosisSafe = _gnosisSafe;\\r\\n }\\r\\n}\\r\\n\",\"keccak256\":\"0xd2641d9481951a753eea302e81b64ccdf06799b852b166761dcb50ac0f076131\",\"license\":\"Unlicense\"},\"contracts/IGnosisWrapper.sol\":{\"content\":\"pragma solidity ^0.8.0;\\r\\n\\r\\ninterface IGnosisWrapper {\\r\\n function initialize(address _accessControl, address _gnosisSafe) external;\\r\\n function gnosisSafe() external view returns(address);\\r\\n}\\r\\n\",\"keccak256\":\"0xff67355c4beff15b94229e0d77aea18a7a2631b0c3590fe03b3abeaf8d833ac3\"}},\"version\":1}", - "bytecode": "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", - "deployedBytecode": "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", - "devdoc": { - "kind": "dev", - "methods": { - "name()": { - "returns": { - "_0": "The module name" - } - }, - "proxiableUUID()": { - "details": "Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the implementation. It is used to validate that the this implementation remains valid after an upgrade. IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier." - }, - "supportsInterface(bytes4)": { - "details": "See {IERC165-supportsInterface}." - }, - "upgradeTo(address)": { - "details": "Upgrade the implementation of the proxy to `newImplementation`. Calls {_authorizeUpgrade}. Emits an {Upgraded} event." - }, - "upgradeToAndCall(address,bytes)": { - "details": "Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call encoded in `data`. Calls {_authorizeUpgrade}. Emits an {Upgraded} event." - } - }, - "version": 1 - }, - "userdoc": { - "kind": "user", - "methods": { - "name()": { - "notice": "Returns the module name" - } - }, - "version": 1 - }, - "storageLayout": { - "storage": [ - { - "astId": 2427, - "contract": "contracts/GnosisWrapper.sol:GnosisWrapper", - "label": "_initialized", - "offset": 0, - "slot": "0", - "type": "t_uint8" - }, - { - "astId": 2430, - "contract": "contracts/GnosisWrapper.sol:GnosisWrapper", - "label": "_initializing", - "offset": 1, - "slot": "0", - "type": "t_bool" - }, - { - "astId": 2409, - "contract": "contracts/GnosisWrapper.sol:GnosisWrapper", - "label": "__gap", - "offset": 0, - "slot": "1", - "type": "t_array(t_uint256)50_storage" - }, - { - "astId": 2706, - "contract": "contracts/GnosisWrapper.sol:GnosisWrapper", - "label": "__gap", - "offset": 0, - "slot": "51", - "type": "t_array(t_uint256)50_storage" - }, - { - "astId": 4073, - "contract": "contracts/GnosisWrapper.sol:GnosisWrapper", - "label": "_supportedInterfaces", - "offset": 0, - "slot": "101", - "type": "t_mapping(t_bytes4,t_bool)" - }, - { - "astId": 1411, - "contract": "contracts/GnosisWrapper.sol:GnosisWrapper", - "label": "accessControl", - "offset": 0, - "slot": "102", - "type": "t_contract(IDAOAccessControl)1841" - }, - { - "astId": 1413, - "contract": "contracts/GnosisWrapper.sol:GnosisWrapper", - "label": "moduleFactory", - "offset": 0, - "slot": "103", - "type": "t_address" - }, - { - "astId": 1415, - "contract": "contracts/GnosisWrapper.sol:GnosisWrapper", - "label": "_name", - "offset": 0, - "slot": "104", - "type": "t_string_storage" - }, - { - "astId": 4133, - "contract": "contracts/GnosisWrapper.sol:GnosisWrapper", - "label": "gnosisSafe", - "offset": 0, - "slot": "105", - "type": "t_address" - } - ], - "types": { - "t_address": { - "encoding": "inplace", - "label": "address", - "numberOfBytes": "20" - }, - "t_array(t_uint256)50_storage": { - "base": "t_uint256", - "encoding": "inplace", - "label": "uint256[50]", - "numberOfBytes": "1600" - }, - "t_bool": { - "encoding": "inplace", - "label": "bool", - "numberOfBytes": "1" - }, - "t_bytes4": { - "encoding": "inplace", - "label": "bytes4", - "numberOfBytes": "4" - }, - "t_contract(IDAOAccessControl)1841": { - "encoding": "inplace", - "label": "contract IDAOAccessControl", - "numberOfBytes": "20" - }, - "t_mapping(t_bytes4,t_bool)": { - "encoding": "mapping", - "key": "t_bytes4", - "label": "mapping(bytes4 => bool)", - "numberOfBytes": "32", - "value": "t_bool" - }, - "t_string_storage": { - "encoding": "bytes", - "label": "string", - "numberOfBytes": "32" - }, - "t_uint256": { - "encoding": "inplace", - "label": "uint256", - "numberOfBytes": "32" - }, - "t_uint8": { - "encoding": "inplace", - "label": "uint8", - "numberOfBytes": "1" - } - } - } -} \ No newline at end of file diff --git a/deployments/goerli/GnosisWrapperFactory.json b/deployments/goerli/GnosisWrapperFactory.json deleted file mode 100644 index 86e2283a..00000000 --- a/deployments/goerli/GnosisWrapperFactory.json +++ /dev/null @@ -1,404 +0,0 @@ -{ - "address": "0x2e759acb781dC9C7277dA5749DDa5Eb79f31871D", - "abi": [ - { - "anonymous": false, - "inputs": [ - { - "indexed": false, - "internalType": "address", - "name": "gnosisSafe", - "type": "address" - } - ], - "name": "GnosisWrapperCreated", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": false, - "internalType": "uint8", - "name": "version", - "type": "uint8" - } - ], - "name": "Initialized", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": true, - "internalType": "address", - "name": "previousOwner", - "type": "address" - }, - { - "indexed": true, - "internalType": "address", - "name": "newOwner", - "type": "address" - } - ], - "name": "OwnershipTransferred", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": false, - "internalType": "string", - "name": "semanticVersion", - "type": "string" - }, - { - "indexed": false, - "internalType": "string", - "name": "frontendURI", - "type": "string" - }, - { - "indexed": false, - "internalType": "address", - "name": "impl", - "type": "address" - } - ], - "name": "VersionCreated", - "type": "event" - }, - { - "inputs": [ - { - "internalType": "string", - "name": "_semanticVersion", - "type": "string" - }, - { - "internalType": "string", - "name": "_frontendURI", - "type": "string" - }, - { - "internalType": "address", - "name": "_impl", - "type": "address" - } - ], - "name": "addVersion", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "creator", - "type": "address" - }, - { - "internalType": "bytes[]", - "name": "data", - "type": "bytes[]" - } - ], - "name": "create", - "outputs": [ - { - "internalType": "address[]", - "name": "", - "type": "address[]" - } - ], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [], - "name": "initialize", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [], - "name": "owner", - "outputs": [ - { - "internalType": "address", - "name": "", - "type": "address" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [], - "name": "renounceOwnership", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "bytes4", - "name": "interfaceId", - "type": "bytes4" - } - ], - "name": "supportsInterface", - "outputs": [ - { - "internalType": "bool", - "name": "", - "type": "bool" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "newOwner", - "type": "address" - } - ], - "name": "transferOwnership", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "uint256", - "name": "", - "type": "uint256" - } - ], - "name": "versionControl", - "outputs": [ - { - "internalType": "string", - "name": "semanticVersion", - "type": "string" - }, - { - "internalType": "string", - "name": "frontendURI", - "type": "string" - }, - { - "internalType": "address", - "name": "impl", - "type": "address" - } - ], - "stateMutability": "view", - "type": "function" - } - ], - "transactionHash": "0x620281e701a30a97bff16e4faed87eed3e6f75ccfc43da23266207e6dc2dfa6a", - "receipt": { - "to": null, - "from": "0x346658f99924B8Cfe8b6A2418070192385848CA9", - "contractAddress": "0x2e759acb781dC9C7277dA5749DDa5Eb79f31871D", - "transactionIndex": 11, - "gasUsed": "1467647", - "logsBloom": "0x00000000000000000000000080000000000000000000000000800000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000001000000000000000000000000000000000000020000000000000000000800000000000080000000000001000000400000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000", - "blockHash": "0x25ef29dff28c602af72625368fc3cd260c480cae686c7a54369e5db48fe7231d", - "transactionHash": "0x620281e701a30a97bff16e4faed87eed3e6f75ccfc43da23266207e6dc2dfa6a", - "logs": [ - { - "transactionIndex": 11, - "blockNumber": 7416092, - "transactionHash": "0x620281e701a30a97bff16e4faed87eed3e6f75ccfc43da23266207e6dc2dfa6a", - "address": "0x2e759acb781dC9C7277dA5749DDa5Eb79f31871D", - "topics": [ - "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x000000000000000000000000346658f99924b8cfe8b6a2418070192385848ca9" - ], - "data": "0x", - "logIndex": 23, - "blockHash": "0x25ef29dff28c602af72625368fc3cd260c480cae686c7a54369e5db48fe7231d" - } - ], - "blockNumber": 7416092, - "cumulativeGasUsed": "2103985", - "status": 1, - "byzantium": true - }, - "args": [], - "numDeployments": 1, - "solcInputHash": "32801c180c72a260c0a67f69b3ec7a05", - "metadata": "{\"compiler\":{\"version\":\"0.8.13+commit.abaa5c0e\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"gnosisSafe\",\"type\":\"address\"}],\"name\":\"GnosisWrapperCreated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"semanticVersion\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"frontendURI\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"impl\",\"type\":\"address\"}],\"name\":\"VersionCreated\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"_semanticVersion\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"_frontendURI\",\"type\":\"string\"},{\"internalType\":\"address\",\"name\":\"_impl\",\"type\":\"address\"}],\"name\":\"addVersion\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"creator\",\"type\":\"address\"},{\"internalType\":\"bytes[]\",\"name\":\"data\",\"type\":\"bytes[]\"}],\"name\":\"create\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"\",\"type\":\"address[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"versionControl\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"semanticVersion\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"frontendURI\",\"type\":\"string\"},{\"internalType\":\"address\",\"name\":\"impl\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"details\":\"GnosisWrapper Factory used to deploy Gnosis Modules\",\"kind\":\"dev\",\"methods\":{\"addVersion(string,string,address)\":{\"details\":\"add a new version to update module users\",\"params\":{\"_frontendURI\":\"IPFS hash of the static frontend\",\"_impl\":\"address of the impl\",\"_semanticVersion\":\"semantic version control\"}},\"create(address,bytes[])\":{\"details\":\"Creates a GnosisWrapper module\",\"params\":{\"creator\":\"The address creating the module\",\"data\":\"The array of bytes used to create the module\"},\"returns\":{\"_0\":\"address[] The array of addresses of the created module\"}},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner.\"},\"supportsInterface(bytes4)\":{\"details\":\"See {IERC165-supportsInterface}.\"},\"transferOwnership(address)\":{\"details\":\"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/GnosisWrapperFactory.sol\":\"GnosisWrapperFactory\"},\"evmVersion\":\"london\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@fractal-framework/core-contracts/contracts/ModuleBase.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\\\";\\r\\nimport \\\"@openzeppelin/contracts/utils/introspection/ERC165Storage.sol\\\";\\r\\nimport \\\"./interfaces/IModuleBase.sol\\\";\\r\\n\\r\\n/// @notice An abstract contract to be inherited by module contracts\\r\\nabstract contract ModuleBase is IModuleBase, UUPSUpgradeable, ERC165Storage {\\r\\n IDAOAccessControl public accessControl;\\r\\n address public moduleFactory;\\r\\n string internal _name;\\r\\n\\r\\n /// @notice Requires that a function caller has the associated role\\r\\n modifier authorized() {\\r\\n if (\\r\\n !accessControl.actionIsAuthorized(\\r\\n msg.sender,\\r\\n address(this),\\r\\n msg.sig\\r\\n )\\r\\n ) {\\r\\n revert NotAuthorized();\\r\\n }\\r\\n _;\\r\\n }\\r\\n\\r\\n /// @notice Function for initializing the contract that can only be called once\\r\\n /// @param _accessControl The address of the access control contract\\r\\n /// @param _moduleFactory The address of the factory deploying the module\\r\\n /// @param __name Human readable string of the module name\\r\\n function __initBase(address _accessControl, address _moduleFactory, string memory __name)\\r\\n internal\\r\\n onlyInitializing\\r\\n {\\r\\n accessControl = IDAOAccessControl(_accessControl);\\r\\n moduleFactory = _moduleFactory;\\r\\n _name = __name;\\r\\n __UUPSUpgradeable_init();\\r\\n _registerInterface(type(IModuleBase).interfaceId);\\r\\n }\\r\\n\\r\\n /// @dev Applies authorized modifier so that an upgrade require the caller to have the correct role\\r\\n /// @param newImplementation The address of the new implementation contract being upgraded to\\r\\n function _authorizeUpgrade(address newImplementation)\\r\\n internal\\r\\n override\\r\\n authorized\\r\\n {}\\r\\n\\r\\n /// @notice Returns the module name\\r\\n /// @return The module name\\r\\n function name() public view virtual returns (string memory) {\\r\\n return _name;\\r\\n }\\r\\n}\\r\\n\",\"keccak256\":\"0xdd4b440c6924fe479e6e3c72e35d109c3af3a9eeb72eab85c65bbe31a2b05dcf\",\"license\":\"Unlicense\"},\"@fractal-framework/core-contracts/contracts/ModuleFactoryBase.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\r\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\\\";\\r\\nimport \\\"@openzeppelin/contracts/utils/introspection/ERC165Storage.sol\\\";\\r\\nimport \\\"./interfaces/IModuleFactoryBase.sol\\\";\\r\\n\\r\\n/// @notice An abstract contract to be inherited by module contracts\\r\\nabstract contract ModuleFactoryBase is\\r\\n IModuleFactoryBase,\\r\\n Ownable,\\r\\n Initializable,\\r\\n ERC165Storage\\r\\n{\\r\\n VersionInfo[] public versionControl;\\r\\n\\r\\n /// @dev add a new version to update module users\\r\\n /// @param _semanticVersion semantic version control\\r\\n /// @param _frontendURI IPFS hash of the static frontend\\r\\n /// @param _impl address of the impl\\r\\n function addVersion(\\r\\n string calldata _semanticVersion,\\r\\n string calldata _frontendURI,\\r\\n address _impl\\r\\n ) external onlyOwner {\\r\\n versionControl.push(VersionInfo(_semanticVersion, _frontendURI, _impl));\\r\\n emit VersionCreated(_semanticVersion, _frontendURI, _impl);\\r\\n }\\r\\n\\r\\n /// @dev Creates a module\\r\\n /// @param creator The address creating the module\\r\\n /// @param data The array of bytes used to create the module\\r\\n /// @return address[] Array of the created module addresses\\r\\n function create(address creator, bytes[] calldata data)\\r\\n external\\r\\n virtual\\r\\n returns (address[] memory);\\r\\n\\r\\n /// @notice Function for initializing the contract that can only be called once\\r\\n function __initFactoryBase() internal onlyInitializing {\\r\\n _registerInterface(type(IModuleFactoryBase).interfaceId);\\r\\n }\\r\\n}\\r\\n\",\"keccak256\":\"0x0720f0e7ad48db40d88974112914d7c374c8e6309285b14a29c53a4a5412b0f2\",\"license\":\"Unlicense\"},\"@fractal-framework/core-contracts/contracts/interfaces/IDAOAccessControl.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\ninterface IDAOAccessControl {\\r\\n struct RoleData {\\r\\n mapping(address => bool) members;\\r\\n string adminRole;\\r\\n }\\r\\n\\r\\n error UnequalArrayLengths();\\r\\n error MissingRole(address account, string role);\\r\\n error OnlySelfRenounce();\\r\\n\\r\\n event ActionRoleAdded(\\r\\n address target,\\r\\n string functionDesc,\\r\\n bytes4 encodedSig,\\r\\n string role\\r\\n );\\r\\n event ActionRoleRemoved(\\r\\n address target,\\r\\n string functionDesc,\\r\\n bytes4 encodedSig,\\r\\n string role\\r\\n );\\r\\n event RoleAdminChanged(\\r\\n string role,\\r\\n string previousAdminRole,\\r\\n string adminRole\\r\\n );\\r\\n event RoleGranted(string role, address account, address admin);\\r\\n event RoleRevoked(string role, address account, address admin);\\r\\n\\r\\n /// @notice Initialize DAO action and role permissions\\r\\n /// @param dao Address to receive DAO role\\r\\n /// @param roles What permissions are assigned to\\r\\n /// @param roleAdmins Roles which have the ability to remove or add members\\r\\n /// @param members Addresses to be granted the specified roles\\r\\n /// @param targets Contract addresses for actions to be defined on\\r\\n /// @param functionDescs Function descriptions used to define actions\\r\\n /// @param actionRoles Roles being granted permission for an action\\r\\n function initialize(\\r\\n address dao,\\r\\n string[] memory roles,\\r\\n string[] memory roleAdmins,\\r\\n address[][] memory members,\\r\\n address[] memory targets,\\r\\n string[] memory functionDescs,\\r\\n string[][] memory actionRoles\\r\\n ) external;\\r\\n\\r\\n /// @notice Grants roles to the specified addresses and defines admin roles\\r\\n /// @notice This function can only be called by the DAO\\r\\n /// @param roles The roles being granted\\r\\n /// @param roleAdmins The roles being granted as admins of the specified of roles\\r\\n /// @param members Addresses being granted each specified role\\r\\n function daoGrantRolesAndAdmins(\\r\\n string[] memory roles,\\r\\n string[] memory roleAdmins,\\r\\n address[][] memory members\\r\\n ) external;\\r\\n\\r\\n /// @notice Grants roles to the specified addresses\\r\\n /// @notice This function can only be called by the DAO\\r\\n /// @param roles The roles being granted\\r\\n /// @param members Addresses being granted each specified role\\r\\n function daoGrantRoles(string[] memory roles, address[][] memory members)\\r\\n external;\\r\\n\\r\\n /// @notice Authorizes roles to execute the specified actions\\r\\n /// @notice This function can only be called by the DAO\\r\\n /// @param targets The contract addresses that the action functions are implemented on\\r\\n /// @param functionDescs The function descriptions used to define the actions\\r\\n /// @param roles Roles being granted permission for an action\\r\\n function daoAddActionsRoles(\\r\\n address[] memory targets,\\r\\n string[] memory functionDescs,\\r\\n string[][] memory roles\\r\\n ) external;\\r\\n\\r\\n /// @notice Removes autorization for roles to execute the specified actions\\r\\n /// @notice This function can only be called by the DAO\\r\\n /// @param targets The contract addresses that the action functions are implemented on\\r\\n /// @param functionDescs The function description used to define the actions\\r\\n /// @param roles Roles that action permissions are being removed on\\r\\n function daoRemoveActionsRoles(\\r\\n address[] memory targets,\\r\\n string[] memory functionDescs,\\r\\n string[][] memory roles\\r\\n ) external;\\r\\n\\r\\n /// @notice Grants a role to the specified address\\r\\n /// @notice This function can only be called by an admin of the specified role\\r\\n /// @param role The role being granted\\r\\n /// @param account The address being granted the specified role\\r\\n function adminGrantRole(string memory role, address account)\\r\\n external;\\r\\n\\r\\n /// @notice Revokes a role from the specified address\\r\\n /// @notice This function can only be called by an admin of the specified role\\r\\n /// @param role The role being revoked\\r\\n /// @param account The address the role is being revoked from\\r\\n function adminRevokeRole(string memory role, address account)\\r\\n external;\\r\\n\\r\\n /// @notice Enables an address to remove one of its own roles\\r\\n /// @notice This function can only be called by the account specified\\r\\n /// @param role The role being renounced\\r\\n /// @param account The address renouncing the role\\r\\n function userRenounceRole(string memory role, address account) external;\\r\\n\\r\\n /// @notice Checks if a caller has the permissions to execute the specific action\\r\\n /// @param caller Address attempting to execute the action\\r\\n /// @param target Contract address corresponding to the action\\r\\n /// @param sig The function signature used to define the action\\r\\n function actionIsAuthorized(\\r\\n address caller,\\r\\n address target,\\r\\n bytes4 sig\\r\\n ) external view returns (bool isAuthorized);\\r\\n\\r\\n /// @notice Returns the roles autorized to execute the specified action\\r\\n /// @param target Contract address corresponding to the action\\r\\n /// @param functionDesc The function description used to define the action\\r\\n function getActionRoles(address target, string memory functionDesc)\\r\\n external\\r\\n view\\r\\n returns (string[] memory roles);\\r\\n\\r\\n /// @notice Checks if a specific role is authorized for an action\\r\\n /// @param role Role that authorization is being checked on\\r\\n /// @param target Contract address corresponding to the action\\r\\n /// @param functionDesc Function description used to define the action\\r\\n /// @return isAuthorized Indicates whether the role is authorized to execute the action\\r\\n function isRoleAuthorized(\\r\\n string calldata role,\\r\\n address target,\\r\\n string memory functionDesc\\r\\n ) external view returns (bool isAuthorized);\\r\\n\\r\\n /// @notice Returns whether the account has been granted the role\\r\\n /// @param role Role that authorization is being checked on\\r\\n /// @param account Address that the role authorization is being check on\\r\\n /// @return boolean Indicates whether the address has been granted the role\\r\\n function hasRole(string memory role, address account)\\r\\n external\\r\\n view\\r\\n returns (bool);\\r\\n\\r\\n /// @notice Returns the role that is the admin of the specified role\\r\\n /// @param role Role that the admin role is being returned for\\r\\n /// @return string The admin role of the specified role\\r\\n function getRoleAdmin(string memory role)\\r\\n external\\r\\n view\\r\\n returns (string memory);\\r\\n\\r\\n /// @return string The string \\\"DAO_ROLE\\\"\\r\\n function DAO_ROLE() external view returns (string memory);\\r\\n}\\r\\n\",\"keccak256\":\"0x8862f578b4fe6a79370b5cbe896e59df4722e95dbb1b0d2e286e335915ed616c\",\"license\":\"Unlicense\"},\"@fractal-framework/core-contracts/contracts/interfaces/IModuleBase.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\nimport \\\"./IDAOAccessControl.sol\\\";\\r\\n\\r\\ninterface IModuleBase {\\r\\n error NotAuthorized();\\r\\n\\r\\n /// @return IDAOAccessControl The Access control interface\\r\\n function accessControl() external view returns (IDAOAccessControl);\\r\\n\\r\\n /// @return string The string \\\"Name\\\"\\r\\n function name() external view returns (string memory);\\r\\n}\\r\\n\",\"keccak256\":\"0xf7aa0a6fc64e3ea68e1fe799390408e62bfd9d1339d6c31c6d862f3af158cca6\",\"license\":\"Unlicense\"},\"@fractal-framework/core-contracts/contracts/interfaces/IModuleFactoryBase.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\n/// @dev The interface to be inherited by Fractal module factories\\r\\ninterface IModuleFactoryBase {\\r\\n event VersionCreated(\\r\\n string semanticVersion,\\r\\n string frontendURI,\\r\\n address impl\\r\\n );\\r\\n struct VersionInfo {\\r\\n string semanticVersion;\\r\\n string frontendURI;\\r\\n address impl;\\r\\n }\\r\\n\\r\\n /// @dev add a new version to update module users\\r\\n /// @param _semanticVersion semantic version control\\r\\n /// @param _frontendURI IPFS hash of the static frontend\\r\\n /// @param _impl address of the impl\\r\\n function addVersion(\\r\\n string calldata _semanticVersion,\\r\\n string calldata _frontendURI,\\r\\n address _impl\\r\\n ) external;\\r\\n\\r\\n /// @dev Creates a module\\r\\n /// @param creator The address creating the module\\r\\n /// @param data The array of bytes used to create the module\\r\\n /// @return address[] Array of the created module addresses\\r\\n function create(address creator, bytes[] calldata data)\\r\\n external\\r\\n returns (address[] memory);\\r\\n}\\r\\n\",\"keccak256\":\"0xefce9f923254a93b1d9d81c56461c04eaf80bc25a741031119562b42a366a049\",\"license\":\"Unlicense\"},\"@openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified\\n * proxy whose upgrades are fully controlled by the current implementation.\\n */\\ninterface IERC1822ProxiableUpgradeable {\\n /**\\n * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation\\n * address.\\n *\\n * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\\n * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\\n * function revert if invoked through a proxy.\\n */\\n function proxiableUUID() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0x77c89f893e403efc6929ba842b7ccf6534d4ffe03afe31670b4a528c0ad78c0f\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/ERC1967/ERC1967UpgradeUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../beacon/IBeaconUpgradeable.sol\\\";\\nimport \\\"../../interfaces/draft-IERC1822Upgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/StorageSlotUpgradeable.sol\\\";\\nimport \\\"../utils/Initializable.sol\\\";\\n\\n/**\\n * @dev This abstract contract provides getters and event emitting update functions for\\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.\\n *\\n * _Available since v4.1._\\n *\\n * @custom:oz-upgrades-unsafe-allow delegatecall\\n */\\nabstract contract ERC1967UpgradeUpgradeable is Initializable {\\n function __ERC1967Upgrade_init() internal onlyInitializing {\\n }\\n\\n function __ERC1967Upgrade_init_unchained() internal onlyInitializing {\\n }\\n // This is the keccak-256 hash of \\\"eip1967.proxy.rollback\\\" subtracted by 1\\n bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;\\n\\n /**\\n * @dev Storage slot with the address of the current implementation.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.implementation\\\" subtracted by 1, and is\\n * validated in the constructor.\\n */\\n bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n /**\\n * @dev Emitted when the implementation is upgraded.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function _getImplementation() internal view returns (address) {\\n return StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new address in the EIP1967 implementation slot.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(AddressUpgradeable.isContract(newImplementation), \\\"ERC1967: new implementation is not a contract\\\");\\n StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\\n }\\n\\n /**\\n * @dev Perform implementation upgrade\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeTo(address newImplementation) internal {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Perform implementation upgrade with additional setup call.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeToAndCall(\\n address newImplementation,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n _upgradeTo(newImplementation);\\n if (data.length > 0 || forceCall) {\\n _functionDelegateCall(newImplementation, data);\\n }\\n }\\n\\n /**\\n * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeToAndCallUUPS(\\n address newImplementation,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n // Upgrades from old implementations will perform a rollback test. This test requires the new\\n // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing\\n // this special case will break upgrade paths from old UUPS implementation to new ones.\\n if (StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT).value) {\\n _setImplementation(newImplementation);\\n } else {\\n try IERC1822ProxiableUpgradeable(newImplementation).proxiableUUID() returns (bytes32 slot) {\\n require(slot == _IMPLEMENTATION_SLOT, \\\"ERC1967Upgrade: unsupported proxiableUUID\\\");\\n } catch {\\n revert(\\\"ERC1967Upgrade: new implementation is not UUPS\\\");\\n }\\n _upgradeToAndCall(newImplementation, data, forceCall);\\n }\\n }\\n\\n /**\\n * @dev Storage slot with the admin of the contract.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.admin\\\" subtracted by 1, and is\\n * validated in the constructor.\\n */\\n bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\\n\\n /**\\n * @dev Emitted when the admin account has changed.\\n */\\n event AdminChanged(address previousAdmin, address newAdmin);\\n\\n /**\\n * @dev Returns the current admin.\\n */\\n function _getAdmin() internal view returns (address) {\\n return StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new address in the EIP1967 admin slot.\\n */\\n function _setAdmin(address newAdmin) private {\\n require(newAdmin != address(0), \\\"ERC1967: new admin is the zero address\\\");\\n StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value = newAdmin;\\n }\\n\\n /**\\n * @dev Changes the admin of the proxy.\\n *\\n * Emits an {AdminChanged} event.\\n */\\n function _changeAdmin(address newAdmin) internal {\\n emit AdminChanged(_getAdmin(), newAdmin);\\n _setAdmin(newAdmin);\\n }\\n\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Emitted when the beacon is upgraded.\\n */\\n event BeaconUpgraded(address indexed beacon);\\n\\n /**\\n * @dev Returns the current beacon.\\n */\\n function _getBeacon() internal view returns (address) {\\n return StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new beacon in the EIP1967 beacon slot.\\n */\\n function _setBeacon(address newBeacon) private {\\n require(AddressUpgradeable.isContract(newBeacon), \\\"ERC1967: new beacon is not a contract\\\");\\n require(\\n AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()),\\n \\\"ERC1967: beacon implementation is not a contract\\\"\\n );\\n StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value = newBeacon;\\n }\\n\\n /**\\n * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does\\n * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).\\n *\\n * Emits a {BeaconUpgraded} event.\\n */\\n function _upgradeBeaconToAndCall(\\n address newBeacon,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n _setBeacon(newBeacon);\\n emit BeaconUpgraded(newBeacon);\\n if (data.length > 0 || forceCall) {\\n _functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data);\\n }\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function _functionDelegateCall(address target, bytes memory data) private returns (bytes memory) {\\n require(AddressUpgradeable.isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return AddressUpgradeable.verifyCallResult(success, returndata, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x315887e846f1e5f8d8fa535a229d318bb9290aaa69485117f1ee8a9a6b3be823\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/beacon/IBeaconUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeaconUpgradeable {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x24b86ac8c005b8c654fbf6ac34a5a4f61580d7273541e83e013e89d66fbf0908\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\\n * reused. This mechanism prevents re-execution of each \\\"step\\\" but allows the creation of new initialization steps in\\n * case an upgrade adds a module that needs to be initialized.\\n *\\n * For example:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * contract MyToken is ERC20Upgradeable {\\n * function initialize() initializer public {\\n * __ERC20_init(\\\"MyToken\\\", \\\"MTK\\\");\\n * }\\n * }\\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\\n * function initializeV2() reinitializer(2) public {\\n * __ERC20Permit_init(\\\"MyToken\\\");\\n * }\\n * }\\n * ```\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n *\\n * [CAUTION]\\n * ====\\n * Avoid leaving a contract uninitialized.\\n *\\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * /// @custom:oz-upgrades-unsafe-allow constructor\\n * constructor() {\\n * _disableInitializers();\\n * }\\n * ```\\n * ====\\n */\\nabstract contract Initializable {\\n /**\\n * @dev Indicates that the contract has been initialized.\\n * @custom:oz-retyped-from bool\\n */\\n uint8 private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Triggered when the contract has been initialized or reinitialized.\\n */\\n event Initialized(uint8 version);\\n\\n /**\\n * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\\n * `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`.\\n */\\n modifier initializer() {\\n bool isTopLevelCall = !_initializing;\\n require(\\n (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\\n \\\"Initializable: contract is already initialized\\\"\\n );\\n _initialized = 1;\\n if (isTopLevelCall) {\\n _initializing = true;\\n }\\n _;\\n if (isTopLevelCall) {\\n _initializing = false;\\n emit Initialized(1);\\n }\\n }\\n\\n /**\\n * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\\n * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\\n * used to initialize parent contracts.\\n *\\n * `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original\\n * initialization step. This is essential to configure modules that are added through upgrades and that require\\n * initialization.\\n *\\n * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\\n * a contract, executing them in the right order is up to the developer or operator.\\n */\\n modifier reinitializer(uint8 version) {\\n require(!_initializing && _initialized < version, \\\"Initializable: contract is already initialized\\\");\\n _initialized = version;\\n _initializing = true;\\n _;\\n _initializing = false;\\n emit Initialized(version);\\n }\\n\\n /**\\n * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\\n * {initializer} and {reinitializer} modifiers, directly or indirectly.\\n */\\n modifier onlyInitializing() {\\n require(_initializing, \\\"Initializable: contract is not initializing\\\");\\n _;\\n }\\n\\n /**\\n * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\\n * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\\n * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\\n * through proxies.\\n */\\n function _disableInitializers() internal virtual {\\n require(!_initializing, \\\"Initializable: contract is initializing\\\");\\n if (_initialized < type(uint8).max) {\\n _initialized = type(uint8).max;\\n emit Initialized(type(uint8).max);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0203dcadc5737d9ef2c211d6fa15d18ebc3b30dfa51903b64870b01a062b0b4e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (proxy/utils/UUPSUpgradeable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../interfaces/draft-IERC1822Upgradeable.sol\\\";\\nimport \\\"../ERC1967/ERC1967UpgradeUpgradeable.sol\\\";\\nimport \\\"./Initializable.sol\\\";\\n\\n/**\\n * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an\\n * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.\\n *\\n * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is\\n * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing\\n * `UUPSUpgradeable` with a custom implementation of upgrades.\\n *\\n * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.\\n *\\n * _Available since v4.1._\\n */\\nabstract contract UUPSUpgradeable is Initializable, IERC1822ProxiableUpgradeable, ERC1967UpgradeUpgradeable {\\n function __UUPSUpgradeable_init() internal onlyInitializing {\\n }\\n\\n function __UUPSUpgradeable_init_unchained() internal onlyInitializing {\\n }\\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment\\n address private immutable __self = address(this);\\n\\n /**\\n * @dev Check that the execution is being performed through a delegatecall call and that the execution context is\\n * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case\\n * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a\\n * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to\\n * fail.\\n */\\n modifier onlyProxy() {\\n require(address(this) != __self, \\\"Function must be called through delegatecall\\\");\\n require(_getImplementation() == __self, \\\"Function must be called through active proxy\\\");\\n _;\\n }\\n\\n /**\\n * @dev Check that the execution is not being performed through a delegate call. This allows a function to be\\n * callable on the implementing contract but not through proxies.\\n */\\n modifier notDelegated() {\\n require(address(this) == __self, \\\"UUPSUpgradeable: must not be called through delegatecall\\\");\\n _;\\n }\\n\\n /**\\n * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the\\n * implementation. It is used to validate that the this implementation remains valid after an upgrade.\\n *\\n * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\\n * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\\n * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.\\n */\\n function proxiableUUID() external view virtual override notDelegated returns (bytes32) {\\n return _IMPLEMENTATION_SLOT;\\n }\\n\\n /**\\n * @dev Upgrade the implementation of the proxy to `newImplementation`.\\n *\\n * Calls {_authorizeUpgrade}.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function upgradeTo(address newImplementation) external virtual onlyProxy {\\n _authorizeUpgrade(newImplementation);\\n _upgradeToAndCallUUPS(newImplementation, new bytes(0), false);\\n }\\n\\n /**\\n * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call\\n * encoded in `data`.\\n *\\n * Calls {_authorizeUpgrade}.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function upgradeToAndCall(address newImplementation, bytes memory data) external payable virtual onlyProxy {\\n _authorizeUpgrade(newImplementation);\\n _upgradeToAndCallUUPS(newImplementation, data, true);\\n }\\n\\n /**\\n * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by\\n * {upgradeTo} and {upgradeToAndCall}.\\n *\\n * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.\\n *\\n * ```solidity\\n * function _authorizeUpgrade(address) internal override onlyOwner {}\\n * ```\\n */\\n function _authorizeUpgrade(address newImplementation) internal virtual;\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x6e36e9b4b71de699c2f3f0d4e4d1aa0b35da99a26e8d5b91ef09ba234b4ef270\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x611aa3f23e59cfdd1863c536776407b3e33d695152a266fa7cfb34440a29a8a3\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StorageSlotUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for reading and writing primitive types to specific storage slots.\\n *\\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\\n * This library helps with reading and writing to such slots without the need for inline assembly.\\n *\\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\\n *\\n * Example usage to set ERC1967 implementation slot:\\n * ```\\n * contract ERC1967 {\\n * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n *\\n * function _getImplementation() internal view returns (address) {\\n * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\\n * }\\n *\\n * function _setImplementation(address newImplementation) internal {\\n * require(Address.isContract(newImplementation), \\\"ERC1967: new implementation is not a contract\\\");\\n * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\\n * }\\n * }\\n * ```\\n *\\n * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._\\n */\\nlibrary StorageSlotUpgradeable {\\n struct AddressSlot {\\n address value;\\n }\\n\\n struct BooleanSlot {\\n bool value;\\n }\\n\\n struct Bytes32Slot {\\n bytes32 value;\\n }\\n\\n struct Uint256Slot {\\n uint256 value;\\n }\\n\\n /**\\n * @dev Returns an `AddressSlot` with member `value` located at `slot`.\\n */\\n function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\\n */\\n function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\\n */\\n function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\\n */\\n function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n}\\n\",\"keccak256\":\"0x09864aea84f01e39313375b5610c73a3c1c68abbdc51e5ccdd25ff977fdadf9a\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor() {\\n _transferOwnership(_msgSender());\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n _checkOwner();\\n _;\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if the sender is not the owner.\\n */\\n function _checkOwner() internal view virtual {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n _transferOwnership(address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n _transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n address oldOwner = _owner;\\n _owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner);\\n }\\n}\\n\",\"keccak256\":\"0xa94b34880e3c1b0b931662cb1c09e5dfa6662f31cba80e07c5ee71cd135c9673\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/draft-IERC1822.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified\\n * proxy whose upgrades are fully controlled by the current implementation.\\n */\\ninterface IERC1822Proxiable {\\n /**\\n * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation\\n * address.\\n *\\n * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\\n * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\\n * function revert if invoked through a proxy.\\n */\\n function proxiableUUID() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0x1d4afe6cb24200cc4545eed814ecf5847277dfe5d613a1707aad5fceecebcfff\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (proxy/ERC1967/ERC1967Proxy.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../Proxy.sol\\\";\\nimport \\\"./ERC1967Upgrade.sol\\\";\\n\\n/**\\n * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an\\n * implementation address that can be changed. This address is stored in storage in the location specified by\\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the\\n * implementation behind the proxy.\\n */\\ncontract ERC1967Proxy is Proxy, ERC1967Upgrade {\\n /**\\n * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.\\n *\\n * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded\\n * function call, and allows initializing the storage of the proxy like a Solidity constructor.\\n */\\n constructor(address _logic, bytes memory _data) payable {\\n _upgradeToAndCall(_logic, _data, false);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function _implementation() internal view virtual override returns (address impl) {\\n return ERC1967Upgrade._getImplementation();\\n }\\n}\\n\",\"keccak256\":\"0xa2b22da3032e50b55f95ec1d13336102d675f341167aa76db571ef7f8bb7975d\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/ERC1967/ERC1967Upgrade.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../beacon/IBeacon.sol\\\";\\nimport \\\"../../interfaces/draft-IERC1822.sol\\\";\\nimport \\\"../../utils/Address.sol\\\";\\nimport \\\"../../utils/StorageSlot.sol\\\";\\n\\n/**\\n * @dev This abstract contract provides getters and event emitting update functions for\\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.\\n *\\n * _Available since v4.1._\\n *\\n * @custom:oz-upgrades-unsafe-allow delegatecall\\n */\\nabstract contract ERC1967Upgrade {\\n // This is the keccak-256 hash of \\\"eip1967.proxy.rollback\\\" subtracted by 1\\n bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;\\n\\n /**\\n * @dev Storage slot with the address of the current implementation.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.implementation\\\" subtracted by 1, and is\\n * validated in the constructor.\\n */\\n bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n /**\\n * @dev Emitted when the implementation is upgraded.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function _getImplementation() internal view returns (address) {\\n return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new address in the EIP1967 implementation slot.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(Address.isContract(newImplementation), \\\"ERC1967: new implementation is not a contract\\\");\\n StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\\n }\\n\\n /**\\n * @dev Perform implementation upgrade\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeTo(address newImplementation) internal {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Perform implementation upgrade with additional setup call.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeToAndCall(\\n address newImplementation,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n _upgradeTo(newImplementation);\\n if (data.length > 0 || forceCall) {\\n Address.functionDelegateCall(newImplementation, data);\\n }\\n }\\n\\n /**\\n * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeToAndCallUUPS(\\n address newImplementation,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n // Upgrades from old implementations will perform a rollback test. This test requires the new\\n // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing\\n // this special case will break upgrade paths from old UUPS implementation to new ones.\\n if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {\\n _setImplementation(newImplementation);\\n } else {\\n try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {\\n require(slot == _IMPLEMENTATION_SLOT, \\\"ERC1967Upgrade: unsupported proxiableUUID\\\");\\n } catch {\\n revert(\\\"ERC1967Upgrade: new implementation is not UUPS\\\");\\n }\\n _upgradeToAndCall(newImplementation, data, forceCall);\\n }\\n }\\n\\n /**\\n * @dev Storage slot with the admin of the contract.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.admin\\\" subtracted by 1, and is\\n * validated in the constructor.\\n */\\n bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\\n\\n /**\\n * @dev Emitted when the admin account has changed.\\n */\\n event AdminChanged(address previousAdmin, address newAdmin);\\n\\n /**\\n * @dev Returns the current admin.\\n */\\n function _getAdmin() internal view returns (address) {\\n return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new address in the EIP1967 admin slot.\\n */\\n function _setAdmin(address newAdmin) private {\\n require(newAdmin != address(0), \\\"ERC1967: new admin is the zero address\\\");\\n StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;\\n }\\n\\n /**\\n * @dev Changes the admin of the proxy.\\n *\\n * Emits an {AdminChanged} event.\\n */\\n function _changeAdmin(address newAdmin) internal {\\n emit AdminChanged(_getAdmin(), newAdmin);\\n _setAdmin(newAdmin);\\n }\\n\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Emitted when the beacon is upgraded.\\n */\\n event BeaconUpgraded(address indexed beacon);\\n\\n /**\\n * @dev Returns the current beacon.\\n */\\n function _getBeacon() internal view returns (address) {\\n return StorageSlot.getAddressSlot(_BEACON_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new beacon in the EIP1967 beacon slot.\\n */\\n function _setBeacon(address newBeacon) private {\\n require(Address.isContract(newBeacon), \\\"ERC1967: new beacon is not a contract\\\");\\n require(\\n Address.isContract(IBeacon(newBeacon).implementation()),\\n \\\"ERC1967: beacon implementation is not a contract\\\"\\n );\\n StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;\\n }\\n\\n /**\\n * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does\\n * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).\\n *\\n * Emits a {BeaconUpgraded} event.\\n */\\n function _upgradeBeaconToAndCall(\\n address newBeacon,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n _setBeacon(newBeacon);\\n emit BeaconUpgraded(newBeacon);\\n if (data.length > 0 || forceCall) {\\n Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xabf3f59bc0e5423eae45e459dbe92e7052c6983628d39008590edc852a62f94a\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internal call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overridden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internal call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback() external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive() external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overridden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {}\\n}\\n\",\"keccak256\":\"0xc130fe33f1b2132158531a87734153293f6d07bc263ff4ac90e85da9c82c0e27\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0xd50a3421ac379ccb1be435fa646d66a65c986b4924f0849839f08692f39dde61\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd6153ce99bcdcce22b124f755e72553295be6abcd63804cfdffceb188b8bef10\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xe2e337e6dde9ef6b680e07338c493ebea1b5fd09b43424112868e9cc1706bca7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Create2.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Create2.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Helper to make usage of the `CREATE2` EVM opcode easier and safer.\\n * `CREATE2` can be used to compute in advance the address where a smart\\n * contract will be deployed, which allows for interesting new mechanisms known\\n * as 'counterfactual interactions'.\\n *\\n * See the https://eips.ethereum.org/EIPS/eip-1014#motivation[EIP] for more\\n * information.\\n */\\nlibrary Create2 {\\n /**\\n * @dev Deploys a contract using `CREATE2`. The address where the contract\\n * will be deployed can be known in advance via {computeAddress}.\\n *\\n * The bytecode for a contract can be obtained from Solidity with\\n * `type(contractName).creationCode`.\\n *\\n * Requirements:\\n *\\n * - `bytecode` must not be empty.\\n * - `salt` must have not been used for `bytecode` already.\\n * - the factory must have a balance of at least `amount`.\\n * - if `amount` is non-zero, `bytecode` must have a `payable` constructor.\\n */\\n function deploy(\\n uint256 amount,\\n bytes32 salt,\\n bytes memory bytecode\\n ) internal returns (address) {\\n address addr;\\n require(address(this).balance >= amount, \\\"Create2: insufficient balance\\\");\\n require(bytecode.length != 0, \\\"Create2: bytecode length is zero\\\");\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt)\\n }\\n require(addr != address(0), \\\"Create2: Failed on deploy\\\");\\n return addr;\\n }\\n\\n /**\\n * @dev Returns the address where a contract will be stored if deployed via {deploy}. Any change in the\\n * `bytecodeHash` or `salt` will result in a new destination address.\\n */\\n function computeAddress(bytes32 salt, bytes32 bytecodeHash) internal view returns (address) {\\n return computeAddress(salt, bytecodeHash, address(this));\\n }\\n\\n /**\\n * @dev Returns the address where a contract will be stored if deployed via {deploy} from a contract located at\\n * `deployer`. If `deployer` is this contract's address, returns the same value as {computeAddress}.\\n */\\n function computeAddress(\\n bytes32 salt,\\n bytes32 bytecodeHash,\\n address deployer\\n ) internal pure returns (address) {\\n bytes32 _data = keccak256(abi.encodePacked(bytes1(0xff), deployer, salt, bytecodeHash));\\n return address(uint160(uint256(_data)));\\n }\\n}\\n\",\"keccak256\":\"0x62237e1773cbf99739b7019f3772a2ff5360d56edb69751b513237f5fcd78571\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/StorageSlot.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for reading and writing primitive types to specific storage slots.\\n *\\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\\n * This library helps with reading and writing to such slots without the need for inline assembly.\\n *\\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\\n *\\n * Example usage to set ERC1967 implementation slot:\\n * ```\\n * contract ERC1967 {\\n * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n *\\n * function _getImplementation() internal view returns (address) {\\n * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\\n * }\\n *\\n * function _setImplementation(address newImplementation) internal {\\n * require(Address.isContract(newImplementation), \\\"ERC1967: new implementation is not a contract\\\");\\n * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\\n * }\\n * }\\n * ```\\n *\\n * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._\\n */\\nlibrary StorageSlot {\\n struct AddressSlot {\\n address value;\\n }\\n\\n struct BooleanSlot {\\n bool value;\\n }\\n\\n struct Bytes32Slot {\\n bytes32 value;\\n }\\n\\n struct Uint256Slot {\\n uint256 value;\\n }\\n\\n /**\\n * @dev Returns an `AddressSlot` with member `value` located at `slot`.\\n */\\n function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\\n */\\n function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\\n */\\n function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\\n */\\n function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd5c50c54bf02740ebd122ff06832546cb5fa84486d52695a9ccfd11666e0c81d\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/ERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165 is IERC165 {\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165).interfaceId;\\n }\\n}\\n\",\"keccak256\":\"0xd10975de010d89fd1c78dc5e8a9a7e7f496198085c151648f20cba166b32582b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/ERC165Storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165Storage.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./ERC165.sol\\\";\\n\\n/**\\n * @dev Storage based implementation of the {IERC165} interface.\\n *\\n * Contracts may inherit from this and call {_registerInterface} to declare\\n * their support of an interface.\\n */\\nabstract contract ERC165Storage is ERC165 {\\n /**\\n * @dev Mapping of interface ids to whether or not it's supported.\\n */\\n mapping(bytes4 => bool) private _supportedInterfaces;\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return super.supportsInterface(interfaceId) || _supportedInterfaces[interfaceId];\\n }\\n\\n /**\\n * @dev Registers the contract as an implementer of the interface defined by\\n * `interfaceId`. Support of the actual ERC165 interface is automatic and\\n * registering its interface id is not required.\\n *\\n * See {IERC165-supportsInterface}.\\n *\\n * Requirements:\\n *\\n * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).\\n */\\n function _registerInterface(bytes4 interfaceId) internal virtual {\\n require(interfaceId != 0xffffffff, \\\"ERC165: invalid interface id\\\");\\n _supportedInterfaces[interfaceId] = true;\\n }\\n}\\n\",\"keccak256\":\"0x77bf0086774bab931413c3388d3a0f7d44cf6878965b72147f57bb0fbbf394bd\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x447a5f3ddc18419d41ff92b3773fb86471b1db25773e07f877f548918a185bf1\",\"license\":\"MIT\"},\"contracts/GnosisWrapper.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\nimport \\\"@fractal-framework/core-contracts/contracts/ModuleBase.sol\\\";\\r\\nimport \\\"./IGnosisWrapper.sol\\\";\\r\\n\\r\\ncontract GnosisWrapper is ModuleBase {\\r\\n address public gnosisSafe;\\r\\n\\r\\n function initialize(address _accessControl, address _gnosisSafe)\\r\\n public\\r\\n initializer\\r\\n {\\r\\n __initBase(_accessControl, msg.sender, \\\"Wrapper Module\\\");\\r\\n _registerInterface(type(IGnosisWrapper).interfaceId);\\r\\n gnosisSafe = _gnosisSafe;\\r\\n }\\r\\n}\\r\\n\",\"keccak256\":\"0xd2641d9481951a753eea302e81b64ccdf06799b852b166761dcb50ac0f076131\",\"license\":\"Unlicense\"},\"contracts/GnosisWrapperFactory.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\nimport \\\"@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol\\\";\\r\\nimport \\\"@openzeppelin/contracts/utils/Create2.sol\\\";\\r\\nimport \\\"./GnosisWrapper.sol\\\";\\r\\n\\r\\nimport \\\"@fractal-framework/core-contracts/contracts/ModuleFactoryBase.sol\\\";\\r\\n\\r\\n/// @dev GnosisWrapper Factory used to deploy Gnosis Modules\\r\\ncontract GnosisWrapperFactory is ModuleFactoryBase {\\r\\n event GnosisWrapperCreated(address gnosisSafe);\\r\\n\\r\\n function initialize() external initializer {\\r\\n __initFactoryBase();\\r\\n }\\r\\n\\r\\n /// @dev Creates a GnosisWrapper module\\r\\n /// @param creator The address creating the module\\r\\n /// @param data The array of bytes used to create the module\\r\\n /// @return address[] The array of addresses of the created module\\r\\n function create(address creator, bytes[] calldata data)\\r\\n external\\r\\n override\\r\\n returns (address[] memory)\\r\\n {\\r\\n address[] memory createdContracts = new address[](1);\\r\\n\\r\\n createdContracts[0] = createGnosisWrapper(creator, data);\\r\\n\\r\\n emit GnosisWrapperCreated(createdContracts[0]);\\r\\n\\r\\n return createdContracts;\\r\\n }\\r\\n\\r\\n function createGnosisWrapper(address creator, bytes[] memory data)\\r\\n private\\r\\n returns (address gnosisWrapper)\\r\\n {\\r\\n // Create wrapper\\r\\n gnosisWrapper = Create2.deploy(\\r\\n 0,\\r\\n keccak256(\\r\\n abi.encodePacked(\\r\\n creator,\\r\\n msg.sender,\\r\\n block.chainid,\\r\\n abi.decode(data[3], (bytes32)) // random salt\\r\\n )\\r\\n ),\\r\\n abi.encodePacked(\\r\\n type(ERC1967Proxy).creationCode,\\r\\n abi.encode(address(abi.decode(data[2], (address))), \\\"\\\") // impl address\\r\\n )\\r\\n );\\r\\n\\r\\n GnosisWrapper(gnosisWrapper).initialize(\\r\\n abi.decode(data[0], (address)),\\r\\n abi.decode(data[1], (address))\\r\\n ); // access Control, gnosisSafe\\r\\n }\\r\\n}\\r\\n\",\"keccak256\":\"0x96bf8dbe55472c506bd90bccc3ca6cdc2a8edd8e500333e635dd301417ed2d53\",\"license\":\"Unlicense\"},\"contracts/IGnosisWrapper.sol\":{\"content\":\"pragma solidity ^0.8.0;\\r\\n\\r\\ninterface IGnosisWrapper {\\r\\n function initialize(address _accessControl, address _gnosisSafe) external;\\r\\n function gnosisSafe() external view returns(address);\\r\\n}\\r\\n\",\"keccak256\":\"0xff67355c4beff15b94229e0d77aea18a7a2631b0c3590fe03b3abeaf8d833ac3\"}},\"version\":1}", - "bytecode": "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", - "deployedBytecode": "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", - "devdoc": { - "details": "GnosisWrapper Factory used to deploy Gnosis Modules", - "kind": "dev", - "methods": { - "addVersion(string,string,address)": { - "details": "add a new version to update module users", - "params": { - "_frontendURI": "IPFS hash of the static frontend", - "_impl": "address of the impl", - "_semanticVersion": "semantic version control" - } - }, - "create(address,bytes[])": { - "details": "Creates a GnosisWrapper module", - "params": { - "creator": "The address creating the module", - "data": "The array of bytes used to create the module" - }, - "returns": { - "_0": "address[] The array of addresses of the created module" - } - }, - "owner()": { - "details": "Returns the address of the current owner." - }, - "renounceOwnership()": { - "details": "Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner." - }, - "supportsInterface(bytes4)": { - "details": "See {IERC165-supportsInterface}." - }, - "transferOwnership(address)": { - "details": "Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner." - } - }, - "version": 1 - }, - "userdoc": { - "kind": "user", - "methods": {}, - "version": 1 - }, - "storageLayout": { - "storage": [ - { - "astId": 3018, - "contract": "contracts/GnosisWrapperFactory.sol:GnosisWrapperFactory", - "label": "_owner", - "offset": 0, - "slot": "0", - "type": "t_address" - }, - { - "astId": 2427, - "contract": "contracts/GnosisWrapperFactory.sol:GnosisWrapperFactory", - "label": "_initialized", - "offset": 20, - "slot": "0", - "type": "t_uint8" - }, - { - "astId": 2430, - "contract": "contracts/GnosisWrapperFactory.sol:GnosisWrapperFactory", - "label": "_initializing", - "offset": 21, - "slot": "0", - "type": "t_bool" - }, - { - "astId": 4073, - "contract": "contracts/GnosisWrapperFactory.sol:GnosisWrapperFactory", - "label": "_supportedInterfaces", - "offset": 0, - "slot": "1", - "type": "t_mapping(t_bytes4,t_bool)" - }, - { - "astId": 1513, - "contract": "contracts/GnosisWrapperFactory.sol:GnosisWrapperFactory", - "label": "versionControl", - "offset": 0, - "slot": "2", - "type": "t_array(t_struct(VersionInfo)1930_storage)dyn_storage" - } - ], - "types": { - "t_address": { - "encoding": "inplace", - "label": "address", - "numberOfBytes": "20" - }, - "t_array(t_struct(VersionInfo)1930_storage)dyn_storage": { - "base": "t_struct(VersionInfo)1930_storage", - "encoding": "dynamic_array", - "label": "struct IModuleFactoryBase.VersionInfo[]", - "numberOfBytes": "32" - }, - "t_bool": { - "encoding": "inplace", - "label": "bool", - "numberOfBytes": "1" - }, - "t_bytes4": { - "encoding": "inplace", - "label": "bytes4", - "numberOfBytes": "4" - }, - "t_mapping(t_bytes4,t_bool)": { - "encoding": "mapping", - "key": "t_bytes4", - "label": "mapping(bytes4 => bool)", - "numberOfBytes": "32", - "value": "t_bool" - }, - "t_string_storage": { - "encoding": "bytes", - "label": "string", - "numberOfBytes": "32" - }, - "t_struct(VersionInfo)1930_storage": { - "encoding": "inplace", - "label": "struct IModuleFactoryBase.VersionInfo", - "members": [ - { - "astId": 1925, - "contract": "contracts/GnosisWrapperFactory.sol:GnosisWrapperFactory", - "label": "semanticVersion", - "offset": 0, - "slot": "0", - "type": "t_string_storage" - }, - { - "astId": 1927, - "contract": "contracts/GnosisWrapperFactory.sol:GnosisWrapperFactory", - "label": "frontendURI", - "offset": 0, - "slot": "1", - "type": "t_string_storage" - }, - { - "astId": 1929, - "contract": "contracts/GnosisWrapperFactory.sol:GnosisWrapperFactory", - "label": "impl", - "offset": 0, - "slot": "2", - "type": "t_address" - } - ], - "numberOfBytes": "96" - }, - "t_uint8": { - "encoding": "inplace", - "label": "uint8", - "numberOfBytes": "1" - } - } - } -} \ No newline at end of file diff --git a/deployments/goerli/solcInputs/32801c180c72a260c0a67f69b3ec7a05.json b/deployments/goerli/solcInputs/32801c180c72a260c0a67f69b3ec7a05.json deleted file mode 100644 index d6237d80..00000000 --- a/deployments/goerli/solcInputs/32801c180c72a260c0a67f69b3ec7a05.json +++ /dev/null @@ -1,149 +0,0 @@ -{ - "language": "Solidity", - "sources": { - "contracts/GnosisWrapper.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\nimport \"@fractal-framework/core-contracts/contracts/ModuleBase.sol\";\r\nimport \"./IGnosisWrapper.sol\";\r\n\r\ncontract GnosisWrapper is ModuleBase {\r\n address public gnosisSafe;\r\n\r\n function initialize(address _accessControl, address _gnosisSafe)\r\n public\r\n initializer\r\n {\r\n __initBase(_accessControl, msg.sender, \"Wrapper Module\");\r\n _registerInterface(type(IGnosisWrapper).interfaceId);\r\n gnosisSafe = _gnosisSafe;\r\n }\r\n}\r\n" - }, - "@fractal-framework/core-contracts/contracts/ModuleBase.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\nimport \"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\";\r\nimport \"@openzeppelin/contracts/utils/introspection/ERC165Storage.sol\";\r\nimport \"./interfaces/IModuleBase.sol\";\r\n\r\n/// @notice An abstract contract to be inherited by module contracts\r\nabstract contract ModuleBase is IModuleBase, UUPSUpgradeable, ERC165Storage {\r\n IDAOAccessControl public accessControl;\r\n address public moduleFactory;\r\n string internal _name;\r\n\r\n /// @notice Requires that a function caller has the associated role\r\n modifier authorized() {\r\n if (\r\n !accessControl.actionIsAuthorized(\r\n msg.sender,\r\n address(this),\r\n msg.sig\r\n )\r\n ) {\r\n revert NotAuthorized();\r\n }\r\n _;\r\n }\r\n\r\n /// @notice Function for initializing the contract that can only be called once\r\n /// @param _accessControl The address of the access control contract\r\n /// @param _moduleFactory The address of the factory deploying the module\r\n /// @param __name Human readable string of the module name\r\n function __initBase(address _accessControl, address _moduleFactory, string memory __name)\r\n internal\r\n onlyInitializing\r\n {\r\n accessControl = IDAOAccessControl(_accessControl);\r\n moduleFactory = _moduleFactory;\r\n _name = __name;\r\n __UUPSUpgradeable_init();\r\n _registerInterface(type(IModuleBase).interfaceId);\r\n }\r\n\r\n /// @dev Applies authorized modifier so that an upgrade require the caller to have the correct role\r\n /// @param newImplementation The address of the new implementation contract being upgraded to\r\n function _authorizeUpgrade(address newImplementation)\r\n internal\r\n override\r\n authorized\r\n {}\r\n\r\n /// @notice Returns the module name\r\n /// @return The module name\r\n function name() public view virtual returns (string memory) {\r\n return _name;\r\n }\r\n}\r\n" - }, - "contracts/IGnosisWrapper.sol": { - "content": "pragma solidity ^0.8.0;\r\n\r\ninterface IGnosisWrapper {\r\n function initialize(address _accessControl, address _gnosisSafe) external;\r\n function gnosisSafe() external view returns(address);\r\n}\r\n" - }, - "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (proxy/utils/UUPSUpgradeable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../../interfaces/draft-IERC1822Upgradeable.sol\";\nimport \"../ERC1967/ERC1967UpgradeUpgradeable.sol\";\nimport \"./Initializable.sol\";\n\n/**\n * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an\n * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.\n *\n * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is\n * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing\n * `UUPSUpgradeable` with a custom implementation of upgrades.\n *\n * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.\n *\n * _Available since v4.1._\n */\nabstract contract UUPSUpgradeable is Initializable, IERC1822ProxiableUpgradeable, ERC1967UpgradeUpgradeable {\n function __UUPSUpgradeable_init() internal onlyInitializing {\n }\n\n function __UUPSUpgradeable_init_unchained() internal onlyInitializing {\n }\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment\n address private immutable __self = address(this);\n\n /**\n * @dev Check that the execution is being performed through a delegatecall call and that the execution context is\n * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case\n * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a\n * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to\n * fail.\n */\n modifier onlyProxy() {\n require(address(this) != __self, \"Function must be called through delegatecall\");\n require(_getImplementation() == __self, \"Function must be called through active proxy\");\n _;\n }\n\n /**\n * @dev Check that the execution is not being performed through a delegate call. This allows a function to be\n * callable on the implementing contract but not through proxies.\n */\n modifier notDelegated() {\n require(address(this) == __self, \"UUPSUpgradeable: must not be called through delegatecall\");\n _;\n }\n\n /**\n * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the\n * implementation. It is used to validate that the this implementation remains valid after an upgrade.\n *\n * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\n * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\n * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.\n */\n function proxiableUUID() external view virtual override notDelegated returns (bytes32) {\n return _IMPLEMENTATION_SLOT;\n }\n\n /**\n * @dev Upgrade the implementation of the proxy to `newImplementation`.\n *\n * Calls {_authorizeUpgrade}.\n *\n * Emits an {Upgraded} event.\n */\n function upgradeTo(address newImplementation) external virtual onlyProxy {\n _authorizeUpgrade(newImplementation);\n _upgradeToAndCallUUPS(newImplementation, new bytes(0), false);\n }\n\n /**\n * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call\n * encoded in `data`.\n *\n * Calls {_authorizeUpgrade}.\n *\n * Emits an {Upgraded} event.\n */\n function upgradeToAndCall(address newImplementation, bytes memory data) external payable virtual onlyProxy {\n _authorizeUpgrade(newImplementation);\n _upgradeToAndCallUUPS(newImplementation, data, true);\n }\n\n /**\n * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by\n * {upgradeTo} and {upgradeToAndCall}.\n *\n * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.\n *\n * ```solidity\n * function _authorizeUpgrade(address) internal override onlyOwner {}\n * ```\n */\n function _authorizeUpgrade(address newImplementation) internal virtual;\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[50] private __gap;\n}\n" - }, - "@openzeppelin/contracts/utils/introspection/ERC165Storage.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165Storage.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./ERC165.sol\";\n\n/**\n * @dev Storage based implementation of the {IERC165} interface.\n *\n * Contracts may inherit from this and call {_registerInterface} to declare\n * their support of an interface.\n */\nabstract contract ERC165Storage is ERC165 {\n /**\n * @dev Mapping of interface ids to whether or not it's supported.\n */\n mapping(bytes4 => bool) private _supportedInterfaces;\n\n /**\n * @dev See {IERC165-supportsInterface}.\n */\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n return super.supportsInterface(interfaceId) || _supportedInterfaces[interfaceId];\n }\n\n /**\n * @dev Registers the contract as an implementer of the interface defined by\n * `interfaceId`. Support of the actual ERC165 interface is automatic and\n * registering its interface id is not required.\n *\n * See {IERC165-supportsInterface}.\n *\n * Requirements:\n *\n * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).\n */\n function _registerInterface(bytes4 interfaceId) internal virtual {\n require(interfaceId != 0xffffffff, \"ERC165: invalid interface id\");\n _supportedInterfaces[interfaceId] = true;\n }\n}\n" - }, - "@fractal-framework/core-contracts/contracts/interfaces/IModuleBase.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\nimport \"./IDAOAccessControl.sol\";\r\n\r\ninterface IModuleBase {\r\n error NotAuthorized();\r\n\r\n /// @return IDAOAccessControl The Access control interface\r\n function accessControl() external view returns (IDAOAccessControl);\r\n\r\n /// @return string The string \"Name\"\r\n function name() external view returns (string memory);\r\n}\r\n" - }, - "@openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified\n * proxy whose upgrades are fully controlled by the current implementation.\n */\ninterface IERC1822ProxiableUpgradeable {\n /**\n * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation\n * address.\n *\n * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\n * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\n * function revert if invoked through a proxy.\n */\n function proxiableUUID() external view returns (bytes32);\n}\n" - }, - "@openzeppelin/contracts-upgradeable/proxy/ERC1967/ERC1967UpgradeUpgradeable.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../beacon/IBeaconUpgradeable.sol\";\nimport \"../../interfaces/draft-IERC1822Upgradeable.sol\";\nimport \"../../utils/AddressUpgradeable.sol\";\nimport \"../../utils/StorageSlotUpgradeable.sol\";\nimport \"../utils/Initializable.sol\";\n\n/**\n * @dev This abstract contract provides getters and event emitting update functions for\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.\n *\n * _Available since v4.1._\n *\n * @custom:oz-upgrades-unsafe-allow delegatecall\n */\nabstract contract ERC1967UpgradeUpgradeable is Initializable {\n function __ERC1967Upgrade_init() internal onlyInitializing {\n }\n\n function __ERC1967Upgrade_init_unchained() internal onlyInitializing {\n }\n // This is the keccak-256 hash of \"eip1967.proxy.rollback\" subtracted by 1\n bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;\n\n /**\n * @dev Storage slot with the address of the current implementation.\n * This is the keccak-256 hash of \"eip1967.proxy.implementation\" subtracted by 1, and is\n * validated in the constructor.\n */\n bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n /**\n * @dev Emitted when the implementation is upgraded.\n */\n event Upgraded(address indexed implementation);\n\n /**\n * @dev Returns the current implementation address.\n */\n function _getImplementation() internal view returns (address) {\n return StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n }\n\n /**\n * @dev Stores a new address in the EIP1967 implementation slot.\n */\n function _setImplementation(address newImplementation) private {\n require(AddressUpgradeable.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n }\n\n /**\n * @dev Perform implementation upgrade\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeTo(address newImplementation) internal {\n _setImplementation(newImplementation);\n emit Upgraded(newImplementation);\n }\n\n /**\n * @dev Perform implementation upgrade with additional setup call.\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeToAndCall(\n address newImplementation,\n bytes memory data,\n bool forceCall\n ) internal {\n _upgradeTo(newImplementation);\n if (data.length > 0 || forceCall) {\n _functionDelegateCall(newImplementation, data);\n }\n }\n\n /**\n * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeToAndCallUUPS(\n address newImplementation,\n bytes memory data,\n bool forceCall\n ) internal {\n // Upgrades from old implementations will perform a rollback test. This test requires the new\n // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing\n // this special case will break upgrade paths from old UUPS implementation to new ones.\n if (StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT).value) {\n _setImplementation(newImplementation);\n } else {\n try IERC1822ProxiableUpgradeable(newImplementation).proxiableUUID() returns (bytes32 slot) {\n require(slot == _IMPLEMENTATION_SLOT, \"ERC1967Upgrade: unsupported proxiableUUID\");\n } catch {\n revert(\"ERC1967Upgrade: new implementation is not UUPS\");\n }\n _upgradeToAndCall(newImplementation, data, forceCall);\n }\n }\n\n /**\n * @dev Storage slot with the admin of the contract.\n * This is the keccak-256 hash of \"eip1967.proxy.admin\" subtracted by 1, and is\n * validated in the constructor.\n */\n bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\n\n /**\n * @dev Emitted when the admin account has changed.\n */\n event AdminChanged(address previousAdmin, address newAdmin);\n\n /**\n * @dev Returns the current admin.\n */\n function _getAdmin() internal view returns (address) {\n return StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value;\n }\n\n /**\n * @dev Stores a new address in the EIP1967 admin slot.\n */\n function _setAdmin(address newAdmin) private {\n require(newAdmin != address(0), \"ERC1967: new admin is the zero address\");\n StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value = newAdmin;\n }\n\n /**\n * @dev Changes the admin of the proxy.\n *\n * Emits an {AdminChanged} event.\n */\n function _changeAdmin(address newAdmin) internal {\n emit AdminChanged(_getAdmin(), newAdmin);\n _setAdmin(newAdmin);\n }\n\n /**\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\n */\n bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\n\n /**\n * @dev Emitted when the beacon is upgraded.\n */\n event BeaconUpgraded(address indexed beacon);\n\n /**\n * @dev Returns the current beacon.\n */\n function _getBeacon() internal view returns (address) {\n return StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value;\n }\n\n /**\n * @dev Stores a new beacon in the EIP1967 beacon slot.\n */\n function _setBeacon(address newBeacon) private {\n require(AddressUpgradeable.isContract(newBeacon), \"ERC1967: new beacon is not a contract\");\n require(\n AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()),\n \"ERC1967: beacon implementation is not a contract\"\n );\n StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value = newBeacon;\n }\n\n /**\n * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does\n * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).\n *\n * Emits a {BeaconUpgraded} event.\n */\n function _upgradeBeaconToAndCall(\n address newBeacon,\n bytes memory data,\n bool forceCall\n ) internal {\n _setBeacon(newBeacon);\n emit BeaconUpgraded(newBeacon);\n if (data.length > 0 || forceCall) {\n _functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data);\n }\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function _functionDelegateCall(address target, bytes memory data) private returns (bytes memory) {\n require(AddressUpgradeable.isContract(target), \"Address: delegate call to non-contract\");\n\n // solhint-disable-next-line avoid-low-level-calls\n (bool success, bytes memory returndata) = target.delegatecall(data);\n return AddressUpgradeable.verifyCallResult(success, returndata, \"Address: low-level delegate call failed\");\n }\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[50] private __gap;\n}\n" - }, - "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../../utils/AddressUpgradeable.sol\";\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\n * reused. This mechanism prevents re-execution of each \"step\" but allows the creation of new initialization steps in\n * case an upgrade adds a module that needs to be initialized.\n *\n * For example:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * contract MyToken is ERC20Upgradeable {\n * function initialize() initializer public {\n * __ERC20_init(\"MyToken\", \"MTK\");\n * }\n * }\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\n * function initializeV2() reinitializer(2) public {\n * __ERC20Permit_init(\"MyToken\");\n * }\n * }\n * ```\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n *\n * [CAUTION]\n * ====\n * Avoid leaving a contract uninitialized.\n *\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * /// @custom:oz-upgrades-unsafe-allow constructor\n * constructor() {\n * _disableInitializers();\n * }\n * ```\n * ====\n */\nabstract contract Initializable {\n /**\n * @dev Indicates that the contract has been initialized.\n * @custom:oz-retyped-from bool\n */\n uint8 private _initialized;\n\n /**\n * @dev Indicates that the contract is in the process of being initialized.\n */\n bool private _initializing;\n\n /**\n * @dev Triggered when the contract has been initialized or reinitialized.\n */\n event Initialized(uint8 version);\n\n /**\n * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\n * `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`.\n */\n modifier initializer() {\n bool isTopLevelCall = !_initializing;\n require(\n (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\n \"Initializable: contract is already initialized\"\n );\n _initialized = 1;\n if (isTopLevelCall) {\n _initializing = true;\n }\n _;\n if (isTopLevelCall) {\n _initializing = false;\n emit Initialized(1);\n }\n }\n\n /**\n * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\n * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\n * used to initialize parent contracts.\n *\n * `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original\n * initialization step. This is essential to configure modules that are added through upgrades and that require\n * initialization.\n *\n * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\n * a contract, executing them in the right order is up to the developer or operator.\n */\n modifier reinitializer(uint8 version) {\n require(!_initializing && _initialized < version, \"Initializable: contract is already initialized\");\n _initialized = version;\n _initializing = true;\n _;\n _initializing = false;\n emit Initialized(version);\n }\n\n /**\n * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\n * {initializer} and {reinitializer} modifiers, directly or indirectly.\n */\n modifier onlyInitializing() {\n require(_initializing, \"Initializable: contract is not initializing\");\n _;\n }\n\n /**\n * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\n * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\n * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\n * through proxies.\n */\n function _disableInitializers() internal virtual {\n require(!_initializing, \"Initializable: contract is initializing\");\n if (_initialized < type(uint8).max) {\n _initialized = type(uint8).max;\n emit Initialized(type(uint8).max);\n }\n }\n}\n" - }, - "@openzeppelin/contracts-upgradeable/proxy/beacon/IBeaconUpgradeable.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\n */\ninterface IBeaconUpgradeable {\n /**\n * @dev Must return an address that can be used as a delegate call target.\n *\n * {BeaconProxy} will check that this address is a contract.\n */\n function implementation() external view returns (address);\n}\n" - }, - "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary AddressUpgradeable {\n /**\n * @dev Returns true if `account` is a contract.\n *\n * [IMPORTANT]\n * ====\n * It is unsafe to assume that an address for which this function returns\n * false is an externally-owned account (EOA) and not a contract.\n *\n * Among others, `isContract` will return false for the following\n * types of addresses:\n *\n * - an externally-owned account\n * - a contract in construction\n * - an address where a contract will be created\n * - an address where a contract lived, but was destroyed\n * ====\n *\n * [IMPORTANT]\n * ====\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\n *\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n * constructor.\n * ====\n */\n function isContract(address account) internal view returns (bool) {\n // This method relies on extcodesize/address.code.length, which returns 0\n // for contracts in construction, since the code is only stored at the end\n // of the constructor execution.\n\n return account.code.length > 0;\n }\n\n /**\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n * `recipient`, forwarding all available gas and reverting on errors.\n *\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\n * imposed by `transfer`, making them unable to receive funds via\n * `transfer`. {sendValue} removes this limitation.\n *\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n *\n * IMPORTANT: because control is transferred to `recipient`, care must be\n * taken to not create reentrancy vulnerabilities. Consider using\n * {ReentrancyGuard} or the\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n */\n function sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n (bool success, ) = recipient.call{value: amount}(\"\");\n require(success, \"Address: unable to send value, recipient may have reverted\");\n }\n\n /**\n * @dev Performs a Solidity function call using a low level `call`. A\n * plain `call` is an unsafe replacement for a function call: use this\n * function instead.\n *\n * If `target` reverts with a revert reason, it is bubbled up by this\n * function (like regular Solidity function calls).\n *\n * Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n *\n * Requirements:\n *\n * - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCall(target, data, \"Address: low-level call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n * `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n *\n * Requirements:\n *\n * - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n * with `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value,\n string memory errorMessage\n ) internal returns (bytes memory) {\n require(address(this).balance >= value, \"Address: insufficient balance for call\");\n require(isContract(target), \"Address: call to non-contract\");\n\n (bool success, bytes memory returndata) = target.call{value: value}(data);\n return verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, \"Address: low-level static call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal view returns (bytes memory) {\n require(isContract(target), \"Address: static call to non-contract\");\n\n (bool success, bytes memory returndata) = target.staticcall(data);\n return verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\n * revert reason using the provided one.\n *\n * _Available since v4.3._\n */\n function verifyCallResult(\n bool success,\n bytes memory returndata,\n string memory errorMessage\n ) internal pure returns (bytes memory) {\n if (success) {\n return returndata;\n } else {\n // Look for revert reason and bubble it up if present\n if (returndata.length > 0) {\n // The easiest way to bubble the revert reason is using memory via assembly\n /// @solidity memory-safe-assembly\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(errorMessage);\n }\n }\n }\n}\n" - }, - "@openzeppelin/contracts-upgradeable/utils/StorageSlotUpgradeable.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Library for reading and writing primitive types to specific storage slots.\n *\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\n * This library helps with reading and writing to such slots without the need for inline assembly.\n *\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\n *\n * Example usage to set ERC1967 implementation slot:\n * ```\n * contract ERC1967 {\n * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n *\n * function _getImplementation() internal view returns (address) {\n * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n * }\n *\n * function _setImplementation(address newImplementation) internal {\n * require(Address.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n * }\n * }\n * ```\n *\n * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._\n */\nlibrary StorageSlotUpgradeable {\n struct AddressSlot {\n address value;\n }\n\n struct BooleanSlot {\n bool value;\n }\n\n struct Bytes32Slot {\n bytes32 value;\n }\n\n struct Uint256Slot {\n uint256 value;\n }\n\n /**\n * @dev Returns an `AddressSlot` with member `value` located at `slot`.\n */\n function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\n */\n function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\n */\n function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\n */\n function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n }\n}\n" - }, - "@openzeppelin/contracts/utils/introspection/ERC165.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC165.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n *\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\n */\nabstract contract ERC165 is IERC165 {\n /**\n * @dev See {IERC165-supportsInterface}.\n */\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n return interfaceId == type(IERC165).interfaceId;\n }\n}\n" - }, - "@openzeppelin/contracts/utils/introspection/IERC165.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n /**\n * @dev Returns true if this contract implements the interface defined by\n * `interfaceId`. See the corresponding\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\n * to learn more about how these ids are created.\n *\n * This function call must use less than 30 000 gas.\n */\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n" - }, - "@fractal-framework/core-contracts/contracts/interfaces/IDAOAccessControl.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\ninterface IDAOAccessControl {\r\n struct RoleData {\r\n mapping(address => bool) members;\r\n string adminRole;\r\n }\r\n\r\n error UnequalArrayLengths();\r\n error MissingRole(address account, string role);\r\n error OnlySelfRenounce();\r\n\r\n event ActionRoleAdded(\r\n address target,\r\n string functionDesc,\r\n bytes4 encodedSig,\r\n string role\r\n );\r\n event ActionRoleRemoved(\r\n address target,\r\n string functionDesc,\r\n bytes4 encodedSig,\r\n string role\r\n );\r\n event RoleAdminChanged(\r\n string role,\r\n string previousAdminRole,\r\n string adminRole\r\n );\r\n event RoleGranted(string role, address account, address admin);\r\n event RoleRevoked(string role, address account, address admin);\r\n\r\n /// @notice Initialize DAO action and role permissions\r\n /// @param dao Address to receive DAO role\r\n /// @param roles What permissions are assigned to\r\n /// @param roleAdmins Roles which have the ability to remove or add members\r\n /// @param members Addresses to be granted the specified roles\r\n /// @param targets Contract addresses for actions to be defined on\r\n /// @param functionDescs Function descriptions used to define actions\r\n /// @param actionRoles Roles being granted permission for an action\r\n function initialize(\r\n address dao,\r\n string[] memory roles,\r\n string[] memory roleAdmins,\r\n address[][] memory members,\r\n address[] memory targets,\r\n string[] memory functionDescs,\r\n string[][] memory actionRoles\r\n ) external;\r\n\r\n /// @notice Grants roles to the specified addresses and defines admin roles\r\n /// @notice This function can only be called by the DAO\r\n /// @param roles The roles being granted\r\n /// @param roleAdmins The roles being granted as admins of the specified of roles\r\n /// @param members Addresses being granted each specified role\r\n function daoGrantRolesAndAdmins(\r\n string[] memory roles,\r\n string[] memory roleAdmins,\r\n address[][] memory members\r\n ) external;\r\n\r\n /// @notice Grants roles to the specified addresses\r\n /// @notice This function can only be called by the DAO\r\n /// @param roles The roles being granted\r\n /// @param members Addresses being granted each specified role\r\n function daoGrantRoles(string[] memory roles, address[][] memory members)\r\n external;\r\n\r\n /// @notice Authorizes roles to execute the specified actions\r\n /// @notice This function can only be called by the DAO\r\n /// @param targets The contract addresses that the action functions are implemented on\r\n /// @param functionDescs The function descriptions used to define the actions\r\n /// @param roles Roles being granted permission for an action\r\n function daoAddActionsRoles(\r\n address[] memory targets,\r\n string[] memory functionDescs,\r\n string[][] memory roles\r\n ) external;\r\n\r\n /// @notice Removes autorization for roles to execute the specified actions\r\n /// @notice This function can only be called by the DAO\r\n /// @param targets The contract addresses that the action functions are implemented on\r\n /// @param functionDescs The function description used to define the actions\r\n /// @param roles Roles that action permissions are being removed on\r\n function daoRemoveActionsRoles(\r\n address[] memory targets,\r\n string[] memory functionDescs,\r\n string[][] memory roles\r\n ) external;\r\n\r\n /// @notice Grants a role to the specified address\r\n /// @notice This function can only be called by an admin of the specified role\r\n /// @param role The role being granted\r\n /// @param account The address being granted the specified role\r\n function adminGrantRole(string memory role, address account)\r\n external;\r\n\r\n /// @notice Revokes a role from the specified address\r\n /// @notice This function can only be called by an admin of the specified role\r\n /// @param role The role being revoked\r\n /// @param account The address the role is being revoked from\r\n function adminRevokeRole(string memory role, address account)\r\n external;\r\n\r\n /// @notice Enables an address to remove one of its own roles\r\n /// @notice This function can only be called by the account specified\r\n /// @param role The role being renounced\r\n /// @param account The address renouncing the role\r\n function userRenounceRole(string memory role, address account) external;\r\n\r\n /// @notice Checks if a caller has the permissions to execute the specific action\r\n /// @param caller Address attempting to execute the action\r\n /// @param target Contract address corresponding to the action\r\n /// @param sig The function signature used to define the action\r\n function actionIsAuthorized(\r\n address caller,\r\n address target,\r\n bytes4 sig\r\n ) external view returns (bool isAuthorized);\r\n\r\n /// @notice Returns the roles autorized to execute the specified action\r\n /// @param target Contract address corresponding to the action\r\n /// @param functionDesc The function description used to define the action\r\n function getActionRoles(address target, string memory functionDesc)\r\n external\r\n view\r\n returns (string[] memory roles);\r\n\r\n /// @notice Checks if a specific role is authorized for an action\r\n /// @param role Role that authorization is being checked on\r\n /// @param target Contract address corresponding to the action\r\n /// @param functionDesc Function description used to define the action\r\n /// @return isAuthorized Indicates whether the role is authorized to execute the action\r\n function isRoleAuthorized(\r\n string calldata role,\r\n address target,\r\n string memory functionDesc\r\n ) external view returns (bool isAuthorized);\r\n\r\n /// @notice Returns whether the account has been granted the role\r\n /// @param role Role that authorization is being checked on\r\n /// @param account Address that the role authorization is being check on\r\n /// @return boolean Indicates whether the address has been granted the role\r\n function hasRole(string memory role, address account)\r\n external\r\n view\r\n returns (bool);\r\n\r\n /// @notice Returns the role that is the admin of the specified role\r\n /// @param role Role that the admin role is being returned for\r\n /// @return string The admin role of the specified role\r\n function getRoleAdmin(string memory role)\r\n external\r\n view\r\n returns (string memory);\r\n\r\n /// @return string The string \"DAO_ROLE\"\r\n function DAO_ROLE() external view returns (string memory);\r\n}\r\n" - }, - "contracts/GnosisWrapperFactory.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\nimport \"@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol\";\r\nimport \"@openzeppelin/contracts/utils/Create2.sol\";\r\nimport \"./GnosisWrapper.sol\";\r\n\r\nimport \"@fractal-framework/core-contracts/contracts/ModuleFactoryBase.sol\";\r\n\r\n/// @dev GnosisWrapper Factory used to deploy Gnosis Modules\r\ncontract GnosisWrapperFactory is ModuleFactoryBase {\r\n event GnosisWrapperCreated(address gnosisSafe);\r\n\r\n function initialize() external initializer {\r\n __initFactoryBase();\r\n }\r\n\r\n /// @dev Creates a GnosisWrapper module\r\n /// @param creator The address creating the module\r\n /// @param data The array of bytes used to create the module\r\n /// @return address[] The array of addresses of the created module\r\n function create(address creator, bytes[] calldata data)\r\n external\r\n override\r\n returns (address[] memory)\r\n {\r\n address[] memory createdContracts = new address[](1);\r\n\r\n createdContracts[0] = createGnosisWrapper(creator, data);\r\n\r\n emit GnosisWrapperCreated(createdContracts[0]);\r\n\r\n return createdContracts;\r\n }\r\n\r\n function createGnosisWrapper(address creator, bytes[] memory data)\r\n private\r\n returns (address gnosisWrapper)\r\n {\r\n // Create wrapper\r\n gnosisWrapper = Create2.deploy(\r\n 0,\r\n keccak256(\r\n abi.encodePacked(\r\n creator,\r\n msg.sender,\r\n block.chainid,\r\n abi.decode(data[3], (bytes32)) // random salt\r\n )\r\n ),\r\n abi.encodePacked(\r\n type(ERC1967Proxy).creationCode,\r\n abi.encode(address(abi.decode(data[2], (address))), \"\") // impl address\r\n )\r\n );\r\n\r\n GnosisWrapper(gnosisWrapper).initialize(\r\n abi.decode(data[0], (address)),\r\n abi.decode(data[1], (address))\r\n ); // access Control, gnosisSafe\r\n }\r\n}\r\n" - }, - "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (proxy/ERC1967/ERC1967Proxy.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../Proxy.sol\";\nimport \"./ERC1967Upgrade.sol\";\n\n/**\n * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an\n * implementation address that can be changed. This address is stored in storage in the location specified by\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the\n * implementation behind the proxy.\n */\ncontract ERC1967Proxy is Proxy, ERC1967Upgrade {\n /**\n * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.\n *\n * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded\n * function call, and allows initializing the storage of the proxy like a Solidity constructor.\n */\n constructor(address _logic, bytes memory _data) payable {\n _upgradeToAndCall(_logic, _data, false);\n }\n\n /**\n * @dev Returns the current implementation address.\n */\n function _implementation() internal view virtual override returns (address impl) {\n return ERC1967Upgrade._getImplementation();\n }\n}\n" - }, - "@openzeppelin/contracts/utils/Create2.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Create2.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Helper to make usage of the `CREATE2` EVM opcode easier and safer.\n * `CREATE2` can be used to compute in advance the address where a smart\n * contract will be deployed, which allows for interesting new mechanisms known\n * as 'counterfactual interactions'.\n *\n * See the https://eips.ethereum.org/EIPS/eip-1014#motivation[EIP] for more\n * information.\n */\nlibrary Create2 {\n /**\n * @dev Deploys a contract using `CREATE2`. The address where the contract\n * will be deployed can be known in advance via {computeAddress}.\n *\n * The bytecode for a contract can be obtained from Solidity with\n * `type(contractName).creationCode`.\n *\n * Requirements:\n *\n * - `bytecode` must not be empty.\n * - `salt` must have not been used for `bytecode` already.\n * - the factory must have a balance of at least `amount`.\n * - if `amount` is non-zero, `bytecode` must have a `payable` constructor.\n */\n function deploy(\n uint256 amount,\n bytes32 salt,\n bytes memory bytecode\n ) internal returns (address) {\n address addr;\n require(address(this).balance >= amount, \"Create2: insufficient balance\");\n require(bytecode.length != 0, \"Create2: bytecode length is zero\");\n /// @solidity memory-safe-assembly\n assembly {\n addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt)\n }\n require(addr != address(0), \"Create2: Failed on deploy\");\n return addr;\n }\n\n /**\n * @dev Returns the address where a contract will be stored if deployed via {deploy}. Any change in the\n * `bytecodeHash` or `salt` will result in a new destination address.\n */\n function computeAddress(bytes32 salt, bytes32 bytecodeHash) internal view returns (address) {\n return computeAddress(salt, bytecodeHash, address(this));\n }\n\n /**\n * @dev Returns the address where a contract will be stored if deployed via {deploy} from a contract located at\n * `deployer`. If `deployer` is this contract's address, returns the same value as {computeAddress}.\n */\n function computeAddress(\n bytes32 salt,\n bytes32 bytecodeHash,\n address deployer\n ) internal pure returns (address) {\n bytes32 _data = keccak256(abi.encodePacked(bytes1(0xff), deployer, salt, bytecodeHash));\n return address(uint160(uint256(_data)));\n }\n}\n" - }, - "@fractal-framework/core-contracts/contracts/ModuleFactoryBase.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\r\nimport \"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\";\r\nimport \"@openzeppelin/contracts/utils/introspection/ERC165Storage.sol\";\r\nimport \"./interfaces/IModuleFactoryBase.sol\";\r\n\r\n/// @notice An abstract contract to be inherited by module contracts\r\nabstract contract ModuleFactoryBase is\r\n IModuleFactoryBase,\r\n Ownable,\r\n Initializable,\r\n ERC165Storage\r\n{\r\n VersionInfo[] public versionControl;\r\n\r\n /// @dev add a new version to update module users\r\n /// @param _semanticVersion semantic version control\r\n /// @param _frontendURI IPFS hash of the static frontend\r\n /// @param _impl address of the impl\r\n function addVersion(\r\n string calldata _semanticVersion,\r\n string calldata _frontendURI,\r\n address _impl\r\n ) external onlyOwner {\r\n versionControl.push(VersionInfo(_semanticVersion, _frontendURI, _impl));\r\n emit VersionCreated(_semanticVersion, _frontendURI, _impl);\r\n }\r\n\r\n /// @dev Creates a module\r\n /// @param creator The address creating the module\r\n /// @param data The array of bytes used to create the module\r\n /// @return address[] Array of the created module addresses\r\n function create(address creator, bytes[] calldata data)\r\n external\r\n virtual\r\n returns (address[] memory);\r\n\r\n /// @notice Function for initializing the contract that can only be called once\r\n function __initFactoryBase() internal onlyInitializing {\r\n _registerInterface(type(IModuleFactoryBase).interfaceId);\r\n }\r\n}\r\n" - }, - "@openzeppelin/contracts/proxy/Proxy.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\n * be specified by overriding the virtual {_implementation} function.\n *\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\n * different contract through the {_delegate} function.\n *\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\n */\nabstract contract Proxy {\n /**\n * @dev Delegates the current call to `implementation`.\n *\n * This function does not return to its internal call site, it will return directly to the external caller.\n */\n function _delegate(address implementation) internal virtual {\n assembly {\n // Copy msg.data. We take full control of memory in this inline assembly\n // block because it will not return to Solidity code. We overwrite the\n // Solidity scratch pad at memory position 0.\n calldatacopy(0, 0, calldatasize())\n\n // Call the implementation.\n // out and outsize are 0 because we don't know the size yet.\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\n\n // Copy the returned data.\n returndatacopy(0, 0, returndatasize())\n\n switch result\n // delegatecall returns 0 on error.\n case 0 {\n revert(0, returndatasize())\n }\n default {\n return(0, returndatasize())\n }\n }\n }\n\n /**\n * @dev This is a virtual function that should be overridden so it returns the address to which the fallback function\n * and {_fallback} should delegate.\n */\n function _implementation() internal view virtual returns (address);\n\n /**\n * @dev Delegates the current call to the address returned by `_implementation()`.\n *\n * This function does not return to its internal call site, it will return directly to the external caller.\n */\n function _fallback() internal virtual {\n _beforeFallback();\n _delegate(_implementation());\n }\n\n /**\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\n * function in the contract matches the call data.\n */\n fallback() external payable virtual {\n _fallback();\n }\n\n /**\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\n * is empty.\n */\n receive() external payable virtual {\n _fallback();\n }\n\n /**\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\n * call, or as part of the Solidity `fallback` or `receive` functions.\n *\n * If overridden should call `super._beforeFallback()`.\n */\n function _beforeFallback() internal virtual {}\n}\n" - }, - "@openzeppelin/contracts/proxy/ERC1967/ERC1967Upgrade.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../beacon/IBeacon.sol\";\nimport \"../../interfaces/draft-IERC1822.sol\";\nimport \"../../utils/Address.sol\";\nimport \"../../utils/StorageSlot.sol\";\n\n/**\n * @dev This abstract contract provides getters and event emitting update functions for\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.\n *\n * _Available since v4.1._\n *\n * @custom:oz-upgrades-unsafe-allow delegatecall\n */\nabstract contract ERC1967Upgrade {\n // This is the keccak-256 hash of \"eip1967.proxy.rollback\" subtracted by 1\n bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;\n\n /**\n * @dev Storage slot with the address of the current implementation.\n * This is the keccak-256 hash of \"eip1967.proxy.implementation\" subtracted by 1, and is\n * validated in the constructor.\n */\n bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n /**\n * @dev Emitted when the implementation is upgraded.\n */\n event Upgraded(address indexed implementation);\n\n /**\n * @dev Returns the current implementation address.\n */\n function _getImplementation() internal view returns (address) {\n return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n }\n\n /**\n * @dev Stores a new address in the EIP1967 implementation slot.\n */\n function _setImplementation(address newImplementation) private {\n require(Address.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n }\n\n /**\n * @dev Perform implementation upgrade\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeTo(address newImplementation) internal {\n _setImplementation(newImplementation);\n emit Upgraded(newImplementation);\n }\n\n /**\n * @dev Perform implementation upgrade with additional setup call.\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeToAndCall(\n address newImplementation,\n bytes memory data,\n bool forceCall\n ) internal {\n _upgradeTo(newImplementation);\n if (data.length > 0 || forceCall) {\n Address.functionDelegateCall(newImplementation, data);\n }\n }\n\n /**\n * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeToAndCallUUPS(\n address newImplementation,\n bytes memory data,\n bool forceCall\n ) internal {\n // Upgrades from old implementations will perform a rollback test. This test requires the new\n // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing\n // this special case will break upgrade paths from old UUPS implementation to new ones.\n if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {\n _setImplementation(newImplementation);\n } else {\n try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {\n require(slot == _IMPLEMENTATION_SLOT, \"ERC1967Upgrade: unsupported proxiableUUID\");\n } catch {\n revert(\"ERC1967Upgrade: new implementation is not UUPS\");\n }\n _upgradeToAndCall(newImplementation, data, forceCall);\n }\n }\n\n /**\n * @dev Storage slot with the admin of the contract.\n * This is the keccak-256 hash of \"eip1967.proxy.admin\" subtracted by 1, and is\n * validated in the constructor.\n */\n bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\n\n /**\n * @dev Emitted when the admin account has changed.\n */\n event AdminChanged(address previousAdmin, address newAdmin);\n\n /**\n * @dev Returns the current admin.\n */\n function _getAdmin() internal view returns (address) {\n return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;\n }\n\n /**\n * @dev Stores a new address in the EIP1967 admin slot.\n */\n function _setAdmin(address newAdmin) private {\n require(newAdmin != address(0), \"ERC1967: new admin is the zero address\");\n StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;\n }\n\n /**\n * @dev Changes the admin of the proxy.\n *\n * Emits an {AdminChanged} event.\n */\n function _changeAdmin(address newAdmin) internal {\n emit AdminChanged(_getAdmin(), newAdmin);\n _setAdmin(newAdmin);\n }\n\n /**\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\n */\n bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\n\n /**\n * @dev Emitted when the beacon is upgraded.\n */\n event BeaconUpgraded(address indexed beacon);\n\n /**\n * @dev Returns the current beacon.\n */\n function _getBeacon() internal view returns (address) {\n return StorageSlot.getAddressSlot(_BEACON_SLOT).value;\n }\n\n /**\n * @dev Stores a new beacon in the EIP1967 beacon slot.\n */\n function _setBeacon(address newBeacon) private {\n require(Address.isContract(newBeacon), \"ERC1967: new beacon is not a contract\");\n require(\n Address.isContract(IBeacon(newBeacon).implementation()),\n \"ERC1967: beacon implementation is not a contract\"\n );\n StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;\n }\n\n /**\n * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does\n * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).\n *\n * Emits a {BeaconUpgraded} event.\n */\n function _upgradeBeaconToAndCall(\n address newBeacon,\n bytes memory data,\n bool forceCall\n ) internal {\n _setBeacon(newBeacon);\n emit BeaconUpgraded(newBeacon);\n if (data.length > 0 || forceCall) {\n Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);\n }\n }\n}\n" - }, - "@openzeppelin/contracts/proxy/beacon/IBeacon.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\n */\ninterface IBeacon {\n /**\n * @dev Must return an address that can be used as a delegate call target.\n *\n * {BeaconProxy} will check that this address is a contract.\n */\n function implementation() external view returns (address);\n}\n" - }, - "@openzeppelin/contracts/interfaces/draft-IERC1822.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified\n * proxy whose upgrades are fully controlled by the current implementation.\n */\ninterface IERC1822Proxiable {\n /**\n * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation\n * address.\n *\n * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\n * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\n * function revert if invoked through a proxy.\n */\n function proxiableUUID() external view returns (bytes32);\n}\n" - }, - "@openzeppelin/contracts/utils/Address.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n /**\n * @dev Returns true if `account` is a contract.\n *\n * [IMPORTANT]\n * ====\n * It is unsafe to assume that an address for which this function returns\n * false is an externally-owned account (EOA) and not a contract.\n *\n * Among others, `isContract` will return false for the following\n * types of addresses:\n *\n * - an externally-owned account\n * - a contract in construction\n * - an address where a contract will be created\n * - an address where a contract lived, but was destroyed\n * ====\n *\n * [IMPORTANT]\n * ====\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\n *\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n * constructor.\n * ====\n */\n function isContract(address account) internal view returns (bool) {\n // This method relies on extcodesize/address.code.length, which returns 0\n // for contracts in construction, since the code is only stored at the end\n // of the constructor execution.\n\n return account.code.length > 0;\n }\n\n /**\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n * `recipient`, forwarding all available gas and reverting on errors.\n *\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\n * imposed by `transfer`, making them unable to receive funds via\n * `transfer`. {sendValue} removes this limitation.\n *\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n *\n * IMPORTANT: because control is transferred to `recipient`, care must be\n * taken to not create reentrancy vulnerabilities. Consider using\n * {ReentrancyGuard} or the\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n */\n function sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n (bool success, ) = recipient.call{value: amount}(\"\");\n require(success, \"Address: unable to send value, recipient may have reverted\");\n }\n\n /**\n * @dev Performs a Solidity function call using a low level `call`. A\n * plain `call` is an unsafe replacement for a function call: use this\n * function instead.\n *\n * If `target` reverts with a revert reason, it is bubbled up by this\n * function (like regular Solidity function calls).\n *\n * Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n *\n * Requirements:\n *\n * - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCall(target, data, \"Address: low-level call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n * `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n *\n * Requirements:\n *\n * - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n * with `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value,\n string memory errorMessage\n ) internal returns (bytes memory) {\n require(address(this).balance >= value, \"Address: insufficient balance for call\");\n require(isContract(target), \"Address: call to non-contract\");\n\n (bool success, bytes memory returndata) = target.call{value: value}(data);\n return verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, \"Address: low-level static call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal view returns (bytes memory) {\n require(isContract(target), \"Address: static call to non-contract\");\n\n (bool success, bytes memory returndata) = target.staticcall(data);\n return verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n require(isContract(target), \"Address: delegate call to non-contract\");\n\n (bool success, bytes memory returndata) = target.delegatecall(data);\n return verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\n * revert reason using the provided one.\n *\n * _Available since v4.3._\n */\n function verifyCallResult(\n bool success,\n bytes memory returndata,\n string memory errorMessage\n ) internal pure returns (bytes memory) {\n if (success) {\n return returndata;\n } else {\n // Look for revert reason and bubble it up if present\n if (returndata.length > 0) {\n // The easiest way to bubble the revert reason is using memory via assembly\n /// @solidity memory-safe-assembly\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(errorMessage);\n }\n }\n }\n}\n" - }, - "@openzeppelin/contracts/utils/StorageSlot.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Library for reading and writing primitive types to specific storage slots.\n *\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\n * This library helps with reading and writing to such slots without the need for inline assembly.\n *\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\n *\n * Example usage to set ERC1967 implementation slot:\n * ```\n * contract ERC1967 {\n * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n *\n * function _getImplementation() internal view returns (address) {\n * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n * }\n *\n * function _setImplementation(address newImplementation) internal {\n * require(Address.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n * }\n * }\n * ```\n *\n * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._\n */\nlibrary StorageSlot {\n struct AddressSlot {\n address value;\n }\n\n struct BooleanSlot {\n bool value;\n }\n\n struct Bytes32Slot {\n bytes32 value;\n }\n\n struct Uint256Slot {\n uint256 value;\n }\n\n /**\n * @dev Returns an `AddressSlot` with member `value` located at `slot`.\n */\n function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\n */\n function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\n */\n function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\n */\n function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n }\n}\n" - }, - "@openzeppelin/contracts/access/Ownable.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n address private _owner;\n\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n /**\n * @dev Initializes the contract setting the deployer as the initial owner.\n */\n constructor() {\n _transferOwnership(_msgSender());\n }\n\n /**\n * @dev Throws if called by any account other than the owner.\n */\n modifier onlyOwner() {\n _checkOwner();\n _;\n }\n\n /**\n * @dev Returns the address of the current owner.\n */\n function owner() public view virtual returns (address) {\n return _owner;\n }\n\n /**\n * @dev Throws if the sender is not the owner.\n */\n function _checkOwner() internal view virtual {\n require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n }\n\n /**\n * @dev Leaves the contract without owner. It will not be possible to call\n * `onlyOwner` functions anymore. Can only be called by the current owner.\n *\n * NOTE: Renouncing ownership will leave the contract without an owner,\n * thereby removing any functionality that is only available to the owner.\n */\n function renounceOwnership() public virtual onlyOwner {\n _transferOwnership(address(0));\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Can only be called by the current owner.\n */\n function transferOwnership(address newOwner) public virtual onlyOwner {\n require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n _transferOwnership(newOwner);\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Internal function without access restriction.\n */\n function _transferOwnership(address newOwner) internal virtual {\n address oldOwner = _owner;\n _owner = newOwner;\n emit OwnershipTransferred(oldOwner, newOwner);\n }\n}\n" - }, - "@fractal-framework/core-contracts/contracts/interfaces/IModuleFactoryBase.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\n/// @dev The interface to be inherited by Fractal module factories\r\ninterface IModuleFactoryBase {\r\n event VersionCreated(\r\n string semanticVersion,\r\n string frontendURI,\r\n address impl\r\n );\r\n struct VersionInfo {\r\n string semanticVersion;\r\n string frontendURI;\r\n address impl;\r\n }\r\n\r\n /// @dev add a new version to update module users\r\n /// @param _semanticVersion semantic version control\r\n /// @param _frontendURI IPFS hash of the static frontend\r\n /// @param _impl address of the impl\r\n function addVersion(\r\n string calldata _semanticVersion,\r\n string calldata _frontendURI,\r\n address _impl\r\n ) external;\r\n\r\n /// @dev Creates a module\r\n /// @param creator The address creating the module\r\n /// @param data The array of bytes used to create the module\r\n /// @return address[] Array of the created module addresses\r\n function create(address creator, bytes[] calldata data)\r\n external\r\n returns (address[] memory);\r\n}\r\n" - }, - "@openzeppelin/contracts/utils/Context.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n function _msgSender() internal view virtual returns (address) {\n return msg.sender;\n }\n\n function _msgData() internal view virtual returns (bytes calldata) {\n return msg.data;\n }\n}\n" - }, - "contracts/mocks/MetaFactory.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\nimport \"@openzeppelin/contracts/utils/introspection/ERC165.sol\";\r\nimport \"@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol\";\r\nimport \"@openzeppelin/contracts/utils/Address.sol\";\r\nimport \"@openzeppelin/contracts-upgradeable/governance/utils/IVotesUpgradeable.sol\";\r\nimport \"@openzeppelin/contracts/utils/Address.sol\";\r\n\r\nimport \"./interfaces/IMetaFactory.sol\";\r\nimport \"@fractal-framework/core-contracts/contracts/interfaces/IDAO.sol\";\r\nimport \"@fractal-framework/core-contracts/contracts/interfaces/IModuleFactoryBase.sol\";\r\n\r\n/// @notice A factory contract for deploying DAOs along with any desired modules within one transaction\r\n/// @dev For the Metafactory to be able to call the execute function on the created DAO, it needs to be given\r\n/// @dev a role that has permissions to call this function. It is critical to have the MetaFactory then revoke\r\n/// @dev this role within the same transaction, so that the MetaFactory cannot be used to perform arbitrary\r\n/// @dev execution calls on the DAO in the future.\r\ncontract MetaFactory is IMetaFactory, ERC165 {\r\n /// @notice Creates a DAO, Access Control, and any modules specified\r\n /// @param daoFactory The address of the DAO factory\r\n /// @param createDAOParams The struct of parameters used for creating the DAO and Access Control contracts\r\n /// @param moduleFactories Array of addresses of the module factories to call\r\n /// @param moduleFactoriesBytes Array of array of bytes to pass to module factory calls\r\n /// @param targets An array of addresses to target for the function calls\r\n /// @param values An array of ether values to send with the function calls\r\n /// @param calldatas An array of bytes defining the function calls\r\n function createDAOAndExecute(\r\n address daoFactory,\r\n IDAOFactory.CreateDAOParams memory createDAOParams,\r\n address[] calldata moduleFactories,\r\n bytes[][] calldata moduleFactoriesBytes,\r\n address[] calldata targets,\r\n uint256[] calldata values,\r\n bytes[] calldata calldatas\r\n ) external {\r\n createDAO(daoFactory, createDAOParams);\r\n createModules(moduleFactories, moduleFactoriesBytes);\r\n execute(targets, values, calldatas);\r\n }\r\n\r\n /// @notice A function for creating the DAO and Access Control contracts\r\n /// @param daoFactory The address of the DAO factory\r\n /// @param createDAOParams The struct of parameters used for creating the DAO and Access Control contracts\r\n function createDAO(\r\n address daoFactory,\r\n IDAOFactory.CreateDAOParams memory createDAOParams\r\n ) internal {\r\n (address dao, address accessControl) = IDAOFactory(daoFactory)\r\n .createDAO(msg.sender, createDAOParams);\r\n\r\n emit DAOCreated(dao, accessControl, msg.sender);\r\n }\r\n\r\n function createModules(\r\n address[] calldata moduleFactories,\r\n bytes[][] calldata moduleFactoriesBytes\r\n ) internal {\r\n if (moduleFactories.length != moduleFactoriesBytes.length)\r\n revert UnequalArrayLengths();\r\n\r\n for (uint256 i; i < moduleFactories.length; i++) {\r\n IModuleFactoryBase(moduleFactories[i]).create(\r\n msg.sender,\r\n moduleFactoriesBytes[i]\r\n );\r\n }\r\n }\r\n\r\n /// @notice A function for executing function calls to deploy an MVD, modules, and initialize them\r\n /// @param targets An array of addresses to target for the function calls\r\n /// @param values An array of ether values to send with the function calls\r\n /// @param calldatas An array of bytes defining the function calls\r\n function execute(\r\n address[] calldata targets,\r\n uint256[] calldata values,\r\n bytes[] calldata calldatas\r\n ) internal {\r\n if (\r\n targets.length != values.length ||\r\n targets.length != calldatas.length\r\n ) revert UnequalArrayLengths();\r\n string\r\n memory errorMessage = \"MetaFactory: call reverted without message\";\r\n uint256 targetlength = targets.length;\r\n for (uint256 i = 0; i < targetlength; ) {\r\n (bool success, bytes memory returndata) = targets[i].call{\r\n value: values[i]\r\n }(calldatas[i]);\r\n Address.verifyCallResult(success, returndata, errorMessage);\r\n unchecked {\r\n i++;\r\n }\r\n }\r\n emit Executed(targets, values, calldatas);\r\n }\r\n\r\n /// @notice Returns whether a given interface ID is supported\r\n /// @param interfaceId An interface ID bytes4 as defined by ERC-165\r\n /// @return bool Indicates whether the interface is supported\r\n function supportsInterface(bytes4 interfaceId)\r\n public\r\n view\r\n virtual\r\n override\r\n returns (bool)\r\n {\r\n return\r\n interfaceId == type(IMetaFactory).interfaceId ||\r\n super.supportsInterface(interfaceId);\r\n }\r\n}\r\n" - }, - "@openzeppelin/contracts-upgradeable/governance/utils/IVotesUpgradeable.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (governance/utils/IVotes.sol)\npragma solidity ^0.8.0;\n\n/**\n * @dev Common interface for {ERC20Votes}, {ERC721Votes}, and other {Votes}-enabled contracts.\n *\n * _Available since v4.5._\n */\ninterface IVotesUpgradeable {\n /**\n * @dev Emitted when an account changes their delegate.\n */\n event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);\n\n /**\n * @dev Emitted when a token transfer or delegate change results in changes to a delegate's number of votes.\n */\n event DelegateVotesChanged(address indexed delegate, uint256 previousBalance, uint256 newBalance);\n\n /**\n * @dev Returns the current amount of votes that `account` has.\n */\n function getVotes(address account) external view returns (uint256);\n\n /**\n * @dev Returns the amount of votes that `account` had at the end of a past block (`blockNumber`).\n */\n function getPastVotes(address account, uint256 blockNumber) external view returns (uint256);\n\n /**\n * @dev Returns the total supply of votes available at the end of a past block (`blockNumber`).\n *\n * NOTE: This value is the sum of all available votes, which is not necessarily the sum of all delegated votes.\n * Votes that have not been delegated are still part of total supply, even though they would not participate in a\n * vote.\n */\n function getPastTotalSupply(uint256 blockNumber) external view returns (uint256);\n\n /**\n * @dev Returns the delegate that `account` has chosen.\n */\n function delegates(address account) external view returns (address);\n\n /**\n * @dev Delegates votes from the sender to `delegatee`.\n */\n function delegate(address delegatee) external;\n\n /**\n * @dev Delegates votes from signer to `delegatee`.\n */\n function delegateBySig(\n address delegatee,\n uint256 nonce,\n uint256 expiry,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) external;\n}\n" - }, - "contracts/mocks/interfaces/IMetaFactory.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\nimport \"@fractal-framework/core-contracts/contracts/interfaces/IDAOFactory.sol\";\r\n\r\ninterface IMetaFactory {\r\n event DAOCreated(address indexed daoAddress, address indexed accessControl, address indexed creator);\r\n event Executed(address[] targets, uint256[] values, bytes[] calldatas);\r\n\r\n error UnequalArrayLengths();\r\n\r\n /// @notice Creates a DAO, Access Control, and any modules specified\r\n /// @param daoFactory The address of the DAO factory\r\n /// @param createDAOParams The struct of parameters used for creating the DAO and Access Control contracts\r\n /// @param moduleFactories Array of addresses of the module factories to call\r\n /// @param moduleFactoriesBytes Array of array of bytes to pass to module factory calls\r\n /// @param targets An array of addresses to target for the function calls\r\n /// @param values An array of ether values to send with the function calls\r\n /// @param calldatas An array of bytes defining the function calls\r\n function createDAOAndExecute(\r\n address daoFactory,\r\n IDAOFactory.CreateDAOParams memory createDAOParams,\r\n address[] calldata moduleFactories,\r\n bytes[][] calldata moduleFactoriesBytes,\r\n address[] calldata targets,\r\n uint256[] calldata values,\r\n bytes[] calldata calldatas\r\n ) external;\r\n}\r\n" - }, - "@fractal-framework/core-contracts/contracts/interfaces/IDAO.sol": { - "content": "import \"./IModuleBase.sol\";\r\n\r\n//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\ninterface IDAO {\r\n error Unauthorized(bytes32 role, address account);\r\n error UnequalArrayLengths();\r\n\r\n event Executed(address[] targets, uint256[] values, bytes[] calldatas);\r\n\r\n /// @notice Function for initializing the Dao\r\n /// @param _accessControl The address of the access control contract\r\n /// @param _moduleFactory The address of the module factory\r\n /// @param _name Name of the Dao\r\n function initialize(address _accessControl, address _moduleFactory, string calldata _name) external;\r\n\r\n /// @notice A function for executing function calls from the DAO\r\n /// @param targets An array of addresses to target for the function calls\r\n /// @param values An array of ether values to send with the function calls\r\n /// @param calldatas An array of bytes defining the function calls\r\n function execute(\r\n address[] calldata targets,\r\n uint256[] calldata values,\r\n bytes[] calldata calldatas\r\n ) external;\r\n}\r\n" - }, - "@fractal-framework/core-contracts/contracts/interfaces/IDAOFactory.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\ninterface IDAOFactory {\r\n struct CreateDAOParams {\r\n address daoImplementation;\r\n address accessControlImplementation;\r\n bytes32 salt;\r\n string daoName;\r\n string[] roles;\r\n string[] rolesAdmins;\r\n address[][] members;\r\n string[] daoFunctionDescs;\r\n string[][] daoActionRoles;\r\n }\r\n\r\n event DAOCreated(address indexed daoAddress, address accessControl, address indexed sender, address indexed creator);\r\n\r\n /// @notice Creates a DAO with an access control contract\r\n /// @param creator Address of the Dao Creator\r\n /// @param createDAOParams Struct of all the parameters required to create a DAO\r\n /// @return dao The address of the deployed DAO proxy contract\r\n /// @return accessControl The address of the deployed access control proxy contract\r\n function createDAO(address creator, CreateDAOParams calldata createDAOParams)\r\n external\r\n returns (address, address);\r\n}\r\n" - }, - "@fractal-framework/core-contracts/contracts/DAOFactory.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\nimport \"@openzeppelin/contracts/utils/introspection/ERC165Storage.sol\";\r\nimport \"@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol\";\r\nimport \"@openzeppelin/contracts/utils/Create2.sol\";\r\n\r\nimport \"./interfaces/IDAOFactory.sol\";\r\nimport \"./interfaces/IDAOAccessControl.sol\";\r\nimport \"./interfaces/IDAO.sol\";\r\n\r\n/// @notice A factory contract for deploying DAOs with an access control contract\r\ncontract DAOFactory is IDAOFactory, ERC165Storage {\r\n constructor() {\r\n _registerInterface(type(IDAOFactory).interfaceId);\r\n }\r\n\r\n /// @notice Creates a DAO with an access control contract\r\n /// @param creator Address of the Dao Creator\r\n /// @param createDAOParams Struct of all the parameters required to create a DAO\r\n /// @return dao The address of the deployed DAO proxy contract\r\n /// @return accessControl The address of the deployed access control proxy contract\r\n function createDAO(\r\n address creator,\r\n CreateDAOParams calldata createDAOParams\r\n ) external returns (address dao, address accessControl) {\r\n dao = _createDAO(creator, createDAOParams);\r\n accessControl = _createAccessControl(creator, createDAOParams);\r\n\r\n address[] memory targets = new address[](\r\n createDAOParams.daoFunctionDescs.length\r\n );\r\n\r\n for (uint256 i; i < createDAOParams.daoFunctionDescs.length; ) {\r\n targets[i] = dao;\r\n unchecked {\r\n i++;\r\n }\r\n }\r\n\r\n IDAO(dao).initialize(\r\n accessControl,\r\n address(this),\r\n createDAOParams.daoName\r\n );\r\n IDAOAccessControl(accessControl).initialize(\r\n dao,\r\n createDAOParams.roles,\r\n createDAOParams.rolesAdmins,\r\n createDAOParams.members,\r\n targets,\r\n createDAOParams.daoFunctionDescs,\r\n createDAOParams.daoActionRoles\r\n );\r\n\r\n emit DAOCreated(dao, accessControl, msg.sender, creator);\r\n }\r\n\r\n /// @notice Creates a DAO contract\r\n /// @param creator Address of the Dao Creator\r\n /// @param createDAOParams Struct of all the parameters required to create a DAO\r\n /// @return _dao The address of the deployed DAO proxy contract\r\n function _createDAO(address creator, CreateDAOParams calldata createDAOParams)\r\n internal\r\n returns (address _dao)\r\n {\r\n _dao = Create2.deploy(\r\n 0,\r\n keccak256(abi.encodePacked(creator, msg.sender, block.chainid, createDAOParams.salt)),\r\n abi.encodePacked(\r\n type(ERC1967Proxy).creationCode,\r\n abi.encode(createDAOParams.daoImplementation, \"\")\r\n )\r\n );\r\n }\r\n\r\n /// @notice Creates a an access control contract\r\n /// @param creator Address of the Dao Creator\r\n /// @param createDAOParams Struct of all the parameters required to create a DAO\r\n /// @return _accessControl The address of the deployed access control proxy contract\r\n function _createAccessControl(address creator, CreateDAOParams memory createDAOParams)\r\n internal\r\n returns (address _accessControl)\r\n {\r\n _accessControl = Create2.deploy(\r\n 0,\r\n keccak256(abi.encodePacked(creator, msg.sender, block.chainid, createDAOParams.salt)),\r\n abi.encodePacked(\r\n type(ERC1967Proxy).creationCode,\r\n abi.encode(createDAOParams.accessControlImplementation, \"\")\r\n )\r\n );\r\n }\r\n}\r\n" - }, - "@fractal-framework/core-contracts/contracts/DAOAccessControl.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\nimport \"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\";\r\nimport \"@openzeppelin/contracts/utils/introspection/ERC165Storage.sol\";\r\n\r\nimport \"./interfaces/IDAOAccessControl.sol\";\r\n\r\n/// @title DAO Access Control\r\n/// @notice Use this contract for managing DAO role based permissions\r\ncontract DAOAccessControl is IDAOAccessControl, ERC165Storage, UUPSUpgradeable {\r\n string public constant DAO_ROLE = \"DAO_ROLE\";\r\n string public constant OPEN_ROLE = \"OPEN_ROLE\";\r\n\r\n mapping(string => RoleData) private _roles;\r\n mapping(address => mapping(bytes4 => string[])) private _actionsToRoles;\r\n\r\n /// @notice Modifier that checks that an account has a specific role. Reverts\r\n /// with a standardized message including the required role.\r\n modifier onlyRole(string memory role) {\r\n _checkRole(role, msg.sender);\r\n _;\r\n }\r\n\r\n /// @notice Initialize DAO action and role permissions\r\n /// @param dao Address to receive DAO role\r\n /// @param roles What permissions are assigned to\r\n /// @param roleAdmins Roles which have the ability to remove or add members\r\n /// @param members Addresses to be granted the specified roles\r\n /// @param targets Contract addresses for actions to be defined on\r\n /// @param functionDescs Function descriptions used to define actions\r\n /// @param actionRoles Roles being granted permission for an action\r\n function initialize(\r\n address dao,\r\n string[] memory roles,\r\n string[] memory roleAdmins,\r\n address[][] memory members,\r\n address[] memory targets,\r\n string[] memory functionDescs,\r\n string[][] memory actionRoles\r\n ) external initializer {\r\n if (\r\n roles.length != roleAdmins.length ||\r\n roles.length != members.length ||\r\n targets.length != functionDescs.length ||\r\n targets.length != actionRoles.length\r\n ) revert UnequalArrayLengths();\r\n\r\n _grantRole(DAO_ROLE, dao);\r\n _grantRolesAndAdmins(roles, roleAdmins, members);\r\n _addActionsRoles(targets, functionDescs, actionRoles);\r\n __UUPSUpgradeable_init();\r\n _registerInterface(type(IDAOAccessControl).interfaceId);\r\n }\r\n\r\n /// @notice Grants roles to the specified addresses and defines admin roles\r\n /// @notice This function can only be called by the DAO\r\n /// @param roles The roles being granted\r\n /// @param roleAdmins The roles being granted as admins of the specified of roles\r\n /// @param members Addresses being granted each specified role\r\n function daoGrantRolesAndAdmins(\r\n string[] memory roles,\r\n string[] memory roleAdmins,\r\n address[][] memory members\r\n ) external onlyRole(DAO_ROLE) {\r\n _grantRolesAndAdmins(roles, roleAdmins, members);\r\n }\r\n\r\n /// @notice Grants roles to the specified addresses\r\n /// @notice This function can only be called by the DAO\r\n /// @param roles The roles being granted\r\n /// @param members Addresses being granted each specified role\r\n function daoGrantRoles(string[] memory roles, address[][] memory members)\r\n external\r\n onlyRole(DAO_ROLE)\r\n {\r\n _grantRoles(roles, members);\r\n }\r\n\r\n /// @notice Authorizes roles to execute the specified actions\r\n /// @notice This function can only be called by the DAO\r\n /// @param targets The contract addresses that the action functions are implemented on\r\n /// @param functionDescs The function descriptions used to define the actions\r\n /// @param roles Roles being granted permission for an action\r\n function daoAddActionsRoles(\r\n address[] memory targets,\r\n string[] memory functionDescs,\r\n string[][] memory roles\r\n ) external onlyRole(DAO_ROLE) {\r\n _addActionsRoles(targets, functionDescs, roles);\r\n }\r\n\r\n /// @notice Removes autorization for roles to execute the specified actions\r\n /// @notice This function can only be called by the DAO\r\n /// @param targets The contract addresses that the action functions are implemented on\r\n /// @param functionDescs The function description used to define the actions\r\n /// @param roles Roles that action permissions are being removed on\r\n function daoRemoveActionsRoles(\r\n address[] memory targets,\r\n string[] memory functionDescs,\r\n string[][] memory roles\r\n ) external onlyRole(DAO_ROLE) {\r\n if (targets.length != functionDescs.length)\r\n revert UnequalArrayLengths();\r\n if (targets.length != roles.length) revert UnequalArrayLengths();\r\n uint256 actionsLength = targets.length;\r\n for (uint256 i = 0; i < actionsLength; ) {\r\n uint256 rolesLength = roles[i].length;\r\n for (uint256 j = 0; j < rolesLength; ) {\r\n _removeActionRole(targets[i], functionDescs[i], roles[i][j]);\r\n unchecked {\r\n j++;\r\n }\r\n }\r\n unchecked {\r\n i++;\r\n }\r\n }\r\n }\r\n\r\n /// @notice Grants a role to the specified address\r\n /// @notice This function can only be called by an admin of the specified role\r\n /// @param role The role being granted\r\n /// @param account The address being granted the specified role\r\n function adminGrantRole(string memory role, address account)\r\n external\r\n onlyRole(getRoleAdmin(role))\r\n {\r\n _grantRole(role, account);\r\n }\r\n\r\n /// @notice Revokes a role from the specified address\r\n /// @notice This function can only be called by an admin of the specified role\r\n /// @param role The role being revoked\r\n /// @param account The address the role is being revoked from\r\n function adminRevokeRole(string memory role, address account)\r\n external\r\n onlyRole(getRoleAdmin(role))\r\n {\r\n _revokeRole(role, account);\r\n }\r\n\r\n /// @notice Enables an address to remove one of its own roles\r\n /// @notice This function can only be called by the account specified\r\n /// @param role The role being renounced\r\n /// @param account The address renouncing the role\r\n function userRenounceRole(string memory role, address account) external {\r\n if (account != msg.sender) {\r\n revert OnlySelfRenounce();\r\n }\r\n\r\n _revokeRole(role, account);\r\n } \r\n\r\n /// @notice Checks if a caller has the permissions to execute the specific action\r\n /// @param caller Address attempting to execute the action\r\n /// @param target Contract address corresponding to the action\r\n /// @param sig The function signature used to define the action\r\n function actionIsAuthorized(\r\n address caller,\r\n address target,\r\n bytes4 sig\r\n ) external view returns (bool isAuthorized) {\r\n string[] memory roles = _actionsToRoles[target][sig];\r\n uint256 roleLength = roles.length;\r\n\r\n for (uint256 i = 0; i < roleLength; ) {\r\n if (hasRole(roles[i], caller)) {\r\n isAuthorized = true;\r\n break;\r\n }\r\n unchecked {\r\n i++;\r\n }\r\n }\r\n }\r\n\r\n /// @notice Returns the roles autorized to execute the specified action\r\n /// @param target Contract address corresponding to the action\r\n /// @param functionDesc The function description used to define the action\r\n function getActionRoles(address target, string memory functionDesc)\r\n external\r\n view\r\n returns (string[] memory roles)\r\n {\r\n bytes4 encodedSig = bytes4(keccak256(abi.encodePacked(functionDesc)));\r\n return _actionsToRoles[target][encodedSig];\r\n }\r\n\r\n /// @notice Checks if a specific role is authorized for an action\r\n /// @param role Role that authorization is being checked on\r\n /// @param target Contract address corresponding to the action\r\n /// @param functionDesc Function description used to define the action\r\n /// @return isAuthorized Indicates whether the role is authorized to execute the action\r\n function isRoleAuthorized(\r\n string calldata role,\r\n address target,\r\n string memory functionDesc\r\n ) external view returns (bool isAuthorized) {\r\n bytes4 encodedSig = bytes4(keccak256(abi.encodePacked(functionDesc)));\r\n string[] memory roles = _actionsToRoles[target][encodedSig];\r\n uint256 rolesLength = roles.length;\r\n\r\n for (uint256 i = 0; i < rolesLength; ) {\r\n if (\r\n keccak256(abi.encodePacked(role)) ==\r\n keccak256(abi.encodePacked(roles[i]))\r\n ) {\r\n isAuthorized = true;\r\n break;\r\n }\r\n unchecked {\r\n i++;\r\n }\r\n }\r\n }\r\n\r\n /// @notice Returns whether the account has been granted the role\r\n /// @param role Role that authorization is being checked on\r\n /// @param account Address that the role authorization is being check on\r\n /// @return boolean Indicates whether the address has been granted the role\r\n function hasRole(string memory role, address account)\r\n public\r\n view\r\n returns (bool)\r\n {\r\n if (\r\n keccak256(bytes(role)) ==\r\n keccak256(bytes(OPEN_ROLE))\r\n ) {\r\n return true;\r\n } else {\r\n return _roles[role].members[account];\r\n }\r\n }\r\n\r\n /// @notice Returns the role that is the admin of the specified role\r\n /// @param role Role that the admin role is being returned for\r\n /// @return string The admin role of the specified role\r\n function getRoleAdmin(string memory role)\r\n public\r\n view\r\n returns (string memory)\r\n {\r\n return _roles[role].adminRole;\r\n }\r\n\r\n /// @notice Sets a role as the admin of another role\r\n /// @param role The role the admin is being set for\r\n /// @param adminRole The role that is being assigned as an admin\r\n function _setRoleAdmin(string memory role, string memory adminRole)\r\n internal\r\n {\r\n string memory previousAdminRole = getRoleAdmin(role);\r\n _roles[role].adminRole = adminRole;\r\n emit RoleAdminChanged(role, previousAdminRole, adminRole);\r\n }\r\n\r\n /// @notice Grants a role to the specified address\r\n /// @param role The role being granted\r\n /// @param account The address being granted the specified role\r\n function _grantRole(string memory role, address account) internal {\r\n if (!hasRole(role, account)) {\r\n _roles[role].members[account] = true;\r\n emit RoleGranted(role, account, msg.sender);\r\n }\r\n }\r\n\r\n /// @notice Revokes a role from the specified address\r\n /// @param role The role being revoked\r\n /// @param account The address the role is being revoked from\r\n function _revokeRole(string memory role, address account) internal {\r\n if (hasRole(role, account)) {\r\n _roles[role].members[account] = false;\r\n emit RoleRevoked(role, account, msg.sender);\r\n }\r\n }\r\n\r\n /// @notice Grants roles to the specified addresses and defines admin roles\r\n /// @param roles The roles being granted\r\n /// @param roleAdmins The roles being granted as admins of the specified of roles\r\n /// @param members Addresses being granted each specified role\r\n function _grantRolesAndAdmins(\r\n string[] memory roles,\r\n string[] memory roleAdmins,\r\n address[][] memory members\r\n ) internal {\r\n if (roles.length != roleAdmins.length) revert UnequalArrayLengths();\r\n if (roles.length != members.length) revert UnequalArrayLengths();\r\n\r\n uint256 rolesLength = roles.length;\r\n for (uint256 i = 0; i < rolesLength; ) {\r\n _setRoleAdmin(roles[i], roleAdmins[i]);\r\n\r\n uint256 membersLength = members[i].length;\r\n for (uint256 j = 0; j < membersLength; ) {\r\n _grantRole(roles[i], members[i][j]);\r\n unchecked {\r\n j++;\r\n }\r\n }\r\n unchecked {\r\n i++;\r\n }\r\n }\r\n }\r\n\r\n /// @notice Grants roles to the specified addresses and defines admin roles\r\n /// @param roles The roles being granted\r\n /// @param members Addresses being granted each specified role\r\n function _grantRoles(string[] memory roles, address[][] memory members)\r\n internal\r\n {\r\n if (roles.length != members.length) revert UnequalArrayLengths();\r\n\r\n uint256 rolesLength = roles.length;\r\n for (uint256 i = 0; i < rolesLength; ) {\r\n uint256 membersLength = members[i].length;\r\n for (uint256 j = 0; j < membersLength; ) {\r\n _grantRole(roles[i], members[i][j]);\r\n unchecked {\r\n j++;\r\n }\r\n }\r\n unchecked {\r\n i++;\r\n }\r\n }\r\n }\r\n\r\n /// @notice Authorizes roles to execute the specified actions\r\n /// @param targets The contract addresses that the action functions are implemented on\r\n /// @param functionDescs The function descriptions used to define the actions\r\n /// @param roles Roles being granted permission for an action\r\n function _addActionsRoles(\r\n address[] memory targets,\r\n string[] memory functionDescs,\r\n string[][] memory roles\r\n ) internal {\r\n if (targets.length != functionDescs.length)\r\n revert UnequalArrayLengths();\r\n if (targets.length != roles.length) revert UnequalArrayLengths();\r\n\r\n uint256 targetsLength = targets.length;\r\n for (uint256 i = 0; i < targetsLength; ) {\r\n uint256 rolesLength = roles[i].length;\r\n for (uint256 j = 0; j < rolesLength; ) {\r\n _addActionRole(targets[i], functionDescs[i], roles[i][j]);\r\n unchecked {\r\n j++;\r\n }\r\n }\r\n unchecked {\r\n i++;\r\n }\r\n }\r\n }\r\n\r\n /// @notice Authorizes a role to execute the specified action\r\n /// @param target The contract address that the action function is implemented on\r\n /// @param functionDesc The function description used to define the action\r\n /// @param role Role being granted permission for an action\r\n function _addActionRole(\r\n address target,\r\n string memory functionDesc,\r\n string memory role\r\n ) internal {\r\n bytes4 encodedSig = bytes4(keccak256(abi.encodePacked(functionDesc)));\r\n _actionsToRoles[target][encodedSig].push(role);\r\n\r\n emit ActionRoleAdded(target, functionDesc, encodedSig, role);\r\n }\r\n\r\n /// @notice Removes authorization of a role to execute the specified action\r\n /// @param target The contract address that the action function is implemented on\r\n /// @param functionDesc The function description used to define the action\r\n /// @param role Role that the action authorization is being removed on\r\n function _removeActionRole(\r\n address target,\r\n string memory functionDesc,\r\n string memory role\r\n ) internal {\r\n bytes4 encodedSig = bytes4(keccak256(abi.encodePacked(functionDesc)));\r\n uint256 rolesLength = _actionsToRoles[target][encodedSig].length;\r\n for (uint256 i = 0; i < rolesLength; ) {\r\n if (\r\n keccak256(\r\n abi.encodePacked(_actionsToRoles[target][encodedSig][i])\r\n ) == keccak256(abi.encodePacked(role))\r\n ) {\r\n _actionsToRoles[target][encodedSig][i] = _actionsToRoles[\r\n target\r\n ][encodedSig][rolesLength - 1];\r\n _actionsToRoles[target][encodedSig].pop();\r\n\r\n emit ActionRoleRemoved(target, functionDesc, encodedSig, role);\r\n\r\n break;\r\n }\r\n unchecked {\r\n i++;\r\n }\r\n }\r\n }\r\n\r\n /// @notice Reverts when msg.sender is not authorized to upgrade the contract\r\n /// @notice Only addresses that have the DAO_ROLE role are authorized\r\n /// @notice Called by upgradeTo and upgradeToAndCall\r\n /// @param newImplementation New implementation contract address being upgraded to\r\n function _authorizeUpgrade(address newImplementation)\r\n internal\r\n override\r\n onlyRole(DAO_ROLE)\r\n {}\r\n\r\n /// @notice Reverts with a standard message if account is missing role\r\n /// @param role Role being checked\r\n /// @param account Address that role is being checked on\r\n function _checkRole(string memory role, address account) internal view {\r\n if (!hasRole(role, account)) {\r\n revert MissingRole(account, role);\r\n }\r\n }\r\n}\r\n" - }, - "@fractal-framework/core-contracts/contracts/DAO.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\nimport \"@openzeppelin/contracts/utils/Address.sol\";\r\n\r\nimport \"./interfaces/IDAO.sol\";\r\nimport \"./ModuleBase.sol\";\r\n\r\n/// @notice A minimum viable DAO contract\r\ncontract DAO is IDAO, ModuleBase {\r\n /// @notice Function for initializing the contract that can only be called once\r\n /// @param _accessControl The address of the access control contract\r\n /// @param _moduleFactory The address of the module factory\r\n /// @param _name Name of the Dao\r\n function initialize(address _accessControl, address _moduleFactory, string calldata _name) external initializer {\r\n __initBase(_accessControl, _moduleFactory, _name);\r\n _registerInterface(type(IDAO).interfaceId);\r\n }\r\n\r\n /// @notice A function for executing function calls from the DAO\r\n /// @param targets An array of addresses to target for the function calls\r\n /// @param values An array of ether values to send with the function calls\r\n /// @param calldatas An array of bytes defining the function calls\r\n function execute(\r\n address[] calldata targets,\r\n uint256[] calldata values,\r\n bytes[] calldata calldatas\r\n ) external authorized {\r\n if (\r\n targets.length != values.length ||\r\n targets.length != calldatas.length\r\n ) revert UnequalArrayLengths();\r\n string memory errorMessage = \"DAO: call reverted without message\";\r\n uint256 targetlength = targets.length;\r\n for (uint256 i = 0; i < targetlength; ) {\r\n (bool success, bytes memory returndata) = targets[i].call{\r\n value: values[i]\r\n }(calldatas[i]);\r\n Address.verifyCallResult(success, returndata, errorMessage);\r\n unchecked {\r\n i++;\r\n }\r\n }\r\n emit Executed(targets, values, calldatas);\r\n }\r\n}\r\n" - }, - "contracts/hardhat-dependency-compiler/@fractal-framework/core-contracts/contracts/DAO.sol": { - "content": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >0.0.0;\nimport '@fractal-framework/core-contracts/contracts/DAO.sol';\n" - }, - "contracts/hardhat-dependency-compiler/@fractal-framework/core-contracts/contracts/DAOAccessControl.sol": { - "content": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >0.0.0;\nimport '@fractal-framework/core-contracts/contracts/DAOAccessControl.sol';\n" - }, - "contracts/hardhat-dependency-compiler/@fractal-framework/core-contracts/contracts/DAOFactory.sol": { - "content": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >0.0.0;\nimport '@fractal-framework/core-contracts/contracts/DAOFactory.sol';\n" - } - }, - "settings": { - "optimizer": { - "enabled": true, - "runs": 200 - }, - "outputSelection": { - "*": { - "*": [ - "abi", - "evm.bytecode", - "evm.deployedBytecode", - "evm.methodIdentifiers", - "metadata", - "storageLayout", - "devdoc", - "userdoc", - "evm.gasEstimates" - ], - "": [ - "ast" - ] - } - }, - "metadata": { - "useLiteralContent": true - } - } -} \ No newline at end of file diff --git a/deployments/rinkeby/.chainId b/deployments/rinkeby/.chainId deleted file mode 100644 index bf0d87ab..00000000 --- a/deployments/rinkeby/.chainId +++ /dev/null @@ -1 +0,0 @@ -4 \ No newline at end of file diff --git a/deployments/rinkeby/GnosisWrapper.json b/deployments/rinkeby/GnosisWrapper.json deleted file mode 100644 index a3798291..00000000 --- a/deployments/rinkeby/GnosisWrapper.json +++ /dev/null @@ -1,381 +0,0 @@ -{ - "address": "0x37B069D2A6D2730306995F5A5b5f38867E8A9f77", - "abi": [ - { - "inputs": [], - "name": "NotAuthorized", - "type": "error" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": false, - "internalType": "address", - "name": "previousAdmin", - "type": "address" - }, - { - "indexed": false, - "internalType": "address", - "name": "newAdmin", - "type": "address" - } - ], - "name": "AdminChanged", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": true, - "internalType": "address", - "name": "beacon", - "type": "address" - } - ], - "name": "BeaconUpgraded", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": false, - "internalType": "uint8", - "name": "version", - "type": "uint8" - } - ], - "name": "Initialized", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": true, - "internalType": "address", - "name": "implementation", - "type": "address" - } - ], - "name": "Upgraded", - "type": "event" - }, - { - "inputs": [], - "name": "accessControl", - "outputs": [ - { - "internalType": "contract IDAOAccessControl", - "name": "", - "type": "address" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [], - "name": "gnosisSafe", - "outputs": [ - { - "internalType": "address", - "name": "", - "type": "address" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "_accessControl", - "type": "address" - }, - { - "internalType": "address", - "name": "_gnosisSafe", - "type": "address" - } - ], - "name": "initialize", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [], - "name": "moduleFactory", - "outputs": [ - { - "internalType": "address", - "name": "", - "type": "address" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [], - "name": "name", - "outputs": [ - { - "internalType": "string", - "name": "", - "type": "string" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [], - "name": "proxiableUUID", - "outputs": [ - { - "internalType": "bytes32", - "name": "", - "type": "bytes32" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "bytes4", - "name": "interfaceId", - "type": "bytes4" - } - ], - "name": "supportsInterface", - "outputs": [ - { - "internalType": "bool", - "name": "", - "type": "bool" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "newImplementation", - "type": "address" - } - ], - "name": "upgradeTo", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "newImplementation", - "type": "address" - }, - { - "internalType": "bytes", - "name": "data", - "type": "bytes" - } - ], - "name": "upgradeToAndCall", - "outputs": [], - "stateMutability": "payable", - "type": "function" - } - ], - "transactionHash": "0x8c34b987c68156dd87212f5616994b5467affb54f6c95be6f649353977a50c29", - "receipt": { - "to": null, - "from": "0x629750317d320B8bB4d48D345A6d699Cc855c4a6", - "contractAddress": "0x37B069D2A6D2730306995F5A5b5f38867E8A9f77", - "transactionIndex": 19, - "gasUsed": "949574", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", - "blockHash": "0x66db4f355e1efc2560507b7fbd069b125c87e957ec94363e8c1b2801987e4765", - "transactionHash": "0x8c34b987c68156dd87212f5616994b5467affb54f6c95be6f649353977a50c29", - "logs": [], - "blockNumber": 11255778, - "cumulativeGasUsed": "5657359", - "status": 1, - "byzantium": true - }, - "args": [], - "numDeployments": 1, - "solcInputHash": "6e6f9d675593c08f2cd8ae1cedebec27", - "metadata": "{\"compiler\":{\"version\":\"0.8.13+commit.abaa5c0e\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"NotAuthorized\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"accessControl\",\"outputs\":[{\"internalType\":\"contract IDAOAccessControl\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"gnosisSafe\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_accessControl\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_gnosisSafe\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"moduleFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"name()\":{\"returns\":{\"_0\":\"The module name\"}},\"proxiableUUID()\":{\"details\":\"Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the implementation. It is used to validate that the this implementation remains valid after an upgrade. IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.\"},\"supportsInterface(bytes4)\":{\"details\":\"See {IERC165-supportsInterface}.\"},\"upgradeTo(address)\":{\"details\":\"Upgrade the implementation of the proxy to `newImplementation`. Calls {_authorizeUpgrade}. Emits an {Upgraded} event.\"},\"upgradeToAndCall(address,bytes)\":{\"details\":\"Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call encoded in `data`. Calls {_authorizeUpgrade}. Emits an {Upgraded} event.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"name()\":{\"notice\":\"Returns the module name\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/GnosisWrapper.sol\":\"GnosisWrapper\"},\"evmVersion\":\"london\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@fractal-framework/core-contracts/contracts/ModuleBase.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\\\";\\r\\nimport \\\"@openzeppelin/contracts/utils/introspection/ERC165Storage.sol\\\";\\r\\nimport \\\"./interfaces/IModuleBase.sol\\\";\\r\\n\\r\\n/// @notice An abstract contract to be inherited by module contracts\\r\\nabstract contract ModuleBase is IModuleBase, UUPSUpgradeable, ERC165Storage {\\r\\n IDAOAccessControl public accessControl;\\r\\n address public moduleFactory;\\r\\n string internal _name;\\r\\n\\r\\n /// @notice Requires that a function caller has the associated role\\r\\n modifier authorized() {\\r\\n if (\\r\\n !accessControl.actionIsAuthorized(\\r\\n msg.sender,\\r\\n address(this),\\r\\n msg.sig\\r\\n )\\r\\n ) {\\r\\n revert NotAuthorized();\\r\\n }\\r\\n _;\\r\\n }\\r\\n\\r\\n /// @notice Function for initializing the contract that can only be called once\\r\\n /// @param _accessControl The address of the access control contract\\r\\n /// @param _moduleFactory The address of the factory deploying the module\\r\\n /// @param __name Human readable string of the module name\\r\\n function __initBase(address _accessControl, address _moduleFactory, string memory __name)\\r\\n internal\\r\\n onlyInitializing\\r\\n {\\r\\n accessControl = IDAOAccessControl(_accessControl);\\r\\n moduleFactory = _moduleFactory;\\r\\n _name = __name;\\r\\n __UUPSUpgradeable_init();\\r\\n _registerInterface(type(IModuleBase).interfaceId);\\r\\n }\\r\\n\\r\\n /// @dev Applies authorized modifier so that an upgrade require the caller to have the correct role\\r\\n /// @param newImplementation The address of the new implementation contract being upgraded to\\r\\n function _authorizeUpgrade(address newImplementation)\\r\\n internal\\r\\n override\\r\\n authorized\\r\\n {}\\r\\n\\r\\n /// @notice Returns the module name\\r\\n /// @return The module name\\r\\n function name() public view virtual returns (string memory) {\\r\\n return _name;\\r\\n }\\r\\n}\\r\\n\",\"keccak256\":\"0xdd4b440c6924fe479e6e3c72e35d109c3af3a9eeb72eab85c65bbe31a2b05dcf\",\"license\":\"Unlicense\"},\"@fractal-framework/core-contracts/contracts/interfaces/IDAOAccessControl.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\ninterface IDAOAccessControl {\\r\\n struct RoleData {\\r\\n mapping(address => bool) members;\\r\\n string adminRole;\\r\\n }\\r\\n\\r\\n error UnequalArrayLengths();\\r\\n error MissingRole(address account, string role);\\r\\n error OnlySelfRenounce();\\r\\n\\r\\n event ActionRoleAdded(\\r\\n address target,\\r\\n string functionDesc,\\r\\n bytes4 encodedSig,\\r\\n string role\\r\\n );\\r\\n event ActionRoleRemoved(\\r\\n address target,\\r\\n string functionDesc,\\r\\n bytes4 encodedSig,\\r\\n string role\\r\\n );\\r\\n event RoleAdminChanged(\\r\\n string role,\\r\\n string previousAdminRole,\\r\\n string adminRole\\r\\n );\\r\\n event RoleGranted(string role, address account, address admin);\\r\\n event RoleRevoked(string role, address account, address admin);\\r\\n\\r\\n /// @notice Initialize DAO action and role permissions\\r\\n /// @param dao Address to receive DAO role\\r\\n /// @param roles What permissions are assigned to\\r\\n /// @param roleAdmins Roles which have the ability to remove or add members\\r\\n /// @param members Addresses to be granted the specified roles\\r\\n /// @param targets Contract addresses for actions to be defined on\\r\\n /// @param functionDescs Function descriptions used to define actions\\r\\n /// @param actionRoles Roles being granted permission for an action\\r\\n function initialize(\\r\\n address dao,\\r\\n string[] memory roles,\\r\\n string[] memory roleAdmins,\\r\\n address[][] memory members,\\r\\n address[] memory targets,\\r\\n string[] memory functionDescs,\\r\\n string[][] memory actionRoles\\r\\n ) external;\\r\\n\\r\\n /// @notice Grants roles to the specified addresses and defines admin roles\\r\\n /// @notice This function can only be called by the DAO\\r\\n /// @param roles The roles being granted\\r\\n /// @param roleAdmins The roles being granted as admins of the specified of roles\\r\\n /// @param members Addresses being granted each specified role\\r\\n function daoGrantRolesAndAdmins(\\r\\n string[] memory roles,\\r\\n string[] memory roleAdmins,\\r\\n address[][] memory members\\r\\n ) external;\\r\\n\\r\\n /// @notice Grants roles to the specified addresses\\r\\n /// @notice This function can only be called by the DAO\\r\\n /// @param roles The roles being granted\\r\\n /// @param members Addresses being granted each specified role\\r\\n function daoGrantRoles(string[] memory roles, address[][] memory members)\\r\\n external;\\r\\n\\r\\n /// @notice Authorizes roles to execute the specified actions\\r\\n /// @notice This function can only be called by the DAO\\r\\n /// @param targets The contract addresses that the action functions are implemented on\\r\\n /// @param functionDescs The function descriptions used to define the actions\\r\\n /// @param roles Roles being granted permission for an action\\r\\n function daoAddActionsRoles(\\r\\n address[] memory targets,\\r\\n string[] memory functionDescs,\\r\\n string[][] memory roles\\r\\n ) external;\\r\\n\\r\\n /// @notice Removes autorization for roles to execute the specified actions\\r\\n /// @notice This function can only be called by the DAO\\r\\n /// @param targets The contract addresses that the action functions are implemented on\\r\\n /// @param functionDescs The function description used to define the actions\\r\\n /// @param roles Roles that action permissions are being removed on\\r\\n function daoRemoveActionsRoles(\\r\\n address[] memory targets,\\r\\n string[] memory functionDescs,\\r\\n string[][] memory roles\\r\\n ) external;\\r\\n\\r\\n /// @notice Grants a role to the specified address\\r\\n /// @notice This function can only be called by an admin of the specified role\\r\\n /// @param role The role being granted\\r\\n /// @param account The address being granted the specified role\\r\\n function adminGrantRole(string memory role, address account)\\r\\n external;\\r\\n\\r\\n /// @notice Revokes a role from the specified address\\r\\n /// @notice This function can only be called by an admin of the specified role\\r\\n /// @param role The role being revoked\\r\\n /// @param account The address the role is being revoked from\\r\\n function adminRevokeRole(string memory role, address account)\\r\\n external;\\r\\n\\r\\n /// @notice Enables an address to remove one of its own roles\\r\\n /// @notice This function can only be called by the account specified\\r\\n /// @param role The role being renounced\\r\\n /// @param account The address renouncing the role\\r\\n function userRenounceRole(string memory role, address account) external;\\r\\n\\r\\n /// @notice Checks if a caller has the permissions to execute the specific action\\r\\n /// @param caller Address attempting to execute the action\\r\\n /// @param target Contract address corresponding to the action\\r\\n /// @param sig The function signature used to define the action\\r\\n function actionIsAuthorized(\\r\\n address caller,\\r\\n address target,\\r\\n bytes4 sig\\r\\n ) external view returns (bool isAuthorized);\\r\\n\\r\\n /// @notice Returns the roles autorized to execute the specified action\\r\\n /// @param target Contract address corresponding to the action\\r\\n /// @param functionDesc The function description used to define the action\\r\\n function getActionRoles(address target, string memory functionDesc)\\r\\n external\\r\\n view\\r\\n returns (string[] memory roles);\\r\\n\\r\\n /// @notice Checks if a specific role is authorized for an action\\r\\n /// @param role Role that authorization is being checked on\\r\\n /// @param target Contract address corresponding to the action\\r\\n /// @param functionDesc Function description used to define the action\\r\\n /// @return isAuthorized Indicates whether the role is authorized to execute the action\\r\\n function isRoleAuthorized(\\r\\n string calldata role,\\r\\n address target,\\r\\n string memory functionDesc\\r\\n ) external view returns (bool isAuthorized);\\r\\n\\r\\n /// @notice Returns whether the account has been granted the role\\r\\n /// @param role Role that authorization is being checked on\\r\\n /// @param account Address that the role authorization is being check on\\r\\n /// @return boolean Indicates whether the address has been granted the role\\r\\n function hasRole(string memory role, address account)\\r\\n external\\r\\n view\\r\\n returns (bool);\\r\\n\\r\\n /// @notice Returns the role that is the admin of the specified role\\r\\n /// @param role Role that the admin role is being returned for\\r\\n /// @return string The admin role of the specified role\\r\\n function getRoleAdmin(string memory role)\\r\\n external\\r\\n view\\r\\n returns (string memory);\\r\\n\\r\\n /// @return string The string \\\"DAO_ROLE\\\"\\r\\n function DAO_ROLE() external view returns (string memory);\\r\\n}\\r\\n\",\"keccak256\":\"0x8862f578b4fe6a79370b5cbe896e59df4722e95dbb1b0d2e286e335915ed616c\",\"license\":\"Unlicense\"},\"@fractal-framework/core-contracts/contracts/interfaces/IModuleBase.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\nimport \\\"./IDAOAccessControl.sol\\\";\\r\\n\\r\\ninterface IModuleBase {\\r\\n error NotAuthorized();\\r\\n\\r\\n /// @return IDAOAccessControl The Access control interface\\r\\n function accessControl() external view returns (IDAOAccessControl);\\r\\n\\r\\n /// @return string The string \\\"Name\\\"\\r\\n function name() external view returns (string memory);\\r\\n}\\r\\n\",\"keccak256\":\"0xf7aa0a6fc64e3ea68e1fe799390408e62bfd9d1339d6c31c6d862f3af158cca6\",\"license\":\"Unlicense\"},\"@openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified\\n * proxy whose upgrades are fully controlled by the current implementation.\\n */\\ninterface IERC1822ProxiableUpgradeable {\\n /**\\n * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation\\n * address.\\n *\\n * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\\n * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\\n * function revert if invoked through a proxy.\\n */\\n function proxiableUUID() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0x77c89f893e403efc6929ba842b7ccf6534d4ffe03afe31670b4a528c0ad78c0f\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/ERC1967/ERC1967UpgradeUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../beacon/IBeaconUpgradeable.sol\\\";\\nimport \\\"../../interfaces/draft-IERC1822Upgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/StorageSlotUpgradeable.sol\\\";\\nimport \\\"../utils/Initializable.sol\\\";\\n\\n/**\\n * @dev This abstract contract provides getters and event emitting update functions for\\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.\\n *\\n * _Available since v4.1._\\n *\\n * @custom:oz-upgrades-unsafe-allow delegatecall\\n */\\nabstract contract ERC1967UpgradeUpgradeable is Initializable {\\n function __ERC1967Upgrade_init() internal onlyInitializing {\\n }\\n\\n function __ERC1967Upgrade_init_unchained() internal onlyInitializing {\\n }\\n // This is the keccak-256 hash of \\\"eip1967.proxy.rollback\\\" subtracted by 1\\n bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;\\n\\n /**\\n * @dev Storage slot with the address of the current implementation.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.implementation\\\" subtracted by 1, and is\\n * validated in the constructor.\\n */\\n bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n /**\\n * @dev Emitted when the implementation is upgraded.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function _getImplementation() internal view returns (address) {\\n return StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new address in the EIP1967 implementation slot.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(AddressUpgradeable.isContract(newImplementation), \\\"ERC1967: new implementation is not a contract\\\");\\n StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\\n }\\n\\n /**\\n * @dev Perform implementation upgrade\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeTo(address newImplementation) internal {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Perform implementation upgrade with additional setup call.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeToAndCall(\\n address newImplementation,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n _upgradeTo(newImplementation);\\n if (data.length > 0 || forceCall) {\\n _functionDelegateCall(newImplementation, data);\\n }\\n }\\n\\n /**\\n * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeToAndCallUUPS(\\n address newImplementation,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n // Upgrades from old implementations will perform a rollback test. This test requires the new\\n // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing\\n // this special case will break upgrade paths from old UUPS implementation to new ones.\\n if (StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT).value) {\\n _setImplementation(newImplementation);\\n } else {\\n try IERC1822ProxiableUpgradeable(newImplementation).proxiableUUID() returns (bytes32 slot) {\\n require(slot == _IMPLEMENTATION_SLOT, \\\"ERC1967Upgrade: unsupported proxiableUUID\\\");\\n } catch {\\n revert(\\\"ERC1967Upgrade: new implementation is not UUPS\\\");\\n }\\n _upgradeToAndCall(newImplementation, data, forceCall);\\n }\\n }\\n\\n /**\\n * @dev Storage slot with the admin of the contract.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.admin\\\" subtracted by 1, and is\\n * validated in the constructor.\\n */\\n bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\\n\\n /**\\n * @dev Emitted when the admin account has changed.\\n */\\n event AdminChanged(address previousAdmin, address newAdmin);\\n\\n /**\\n * @dev Returns the current admin.\\n */\\n function _getAdmin() internal view returns (address) {\\n return StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new address in the EIP1967 admin slot.\\n */\\n function _setAdmin(address newAdmin) private {\\n require(newAdmin != address(0), \\\"ERC1967: new admin is the zero address\\\");\\n StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value = newAdmin;\\n }\\n\\n /**\\n * @dev Changes the admin of the proxy.\\n *\\n * Emits an {AdminChanged} event.\\n */\\n function _changeAdmin(address newAdmin) internal {\\n emit AdminChanged(_getAdmin(), newAdmin);\\n _setAdmin(newAdmin);\\n }\\n\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Emitted when the beacon is upgraded.\\n */\\n event BeaconUpgraded(address indexed beacon);\\n\\n /**\\n * @dev Returns the current beacon.\\n */\\n function _getBeacon() internal view returns (address) {\\n return StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new beacon in the EIP1967 beacon slot.\\n */\\n function _setBeacon(address newBeacon) private {\\n require(AddressUpgradeable.isContract(newBeacon), \\\"ERC1967: new beacon is not a contract\\\");\\n require(\\n AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()),\\n \\\"ERC1967: beacon implementation is not a contract\\\"\\n );\\n StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value = newBeacon;\\n }\\n\\n /**\\n * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does\\n * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).\\n *\\n * Emits a {BeaconUpgraded} event.\\n */\\n function _upgradeBeaconToAndCall(\\n address newBeacon,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n _setBeacon(newBeacon);\\n emit BeaconUpgraded(newBeacon);\\n if (data.length > 0 || forceCall) {\\n _functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data);\\n }\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function _functionDelegateCall(address target, bytes memory data) private returns (bytes memory) {\\n require(AddressUpgradeable.isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return AddressUpgradeable.verifyCallResult(success, returndata, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x315887e846f1e5f8d8fa535a229d318bb9290aaa69485117f1ee8a9a6b3be823\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/beacon/IBeaconUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeaconUpgradeable {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x24b86ac8c005b8c654fbf6ac34a5a4f61580d7273541e83e013e89d66fbf0908\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\\n * reused. This mechanism prevents re-execution of each \\\"step\\\" but allows the creation of new initialization steps in\\n * case an upgrade adds a module that needs to be initialized.\\n *\\n * For example:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * contract MyToken is ERC20Upgradeable {\\n * function initialize() initializer public {\\n * __ERC20_init(\\\"MyToken\\\", \\\"MTK\\\");\\n * }\\n * }\\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\\n * function initializeV2() reinitializer(2) public {\\n * __ERC20Permit_init(\\\"MyToken\\\");\\n * }\\n * }\\n * ```\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n *\\n * [CAUTION]\\n * ====\\n * Avoid leaving a contract uninitialized.\\n *\\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * /// @custom:oz-upgrades-unsafe-allow constructor\\n * constructor() {\\n * _disableInitializers();\\n * }\\n * ```\\n * ====\\n */\\nabstract contract Initializable {\\n /**\\n * @dev Indicates that the contract has been initialized.\\n * @custom:oz-retyped-from bool\\n */\\n uint8 private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Triggered when the contract has been initialized or reinitialized.\\n */\\n event Initialized(uint8 version);\\n\\n /**\\n * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\\n * `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`.\\n */\\n modifier initializer() {\\n bool isTopLevelCall = !_initializing;\\n require(\\n (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\\n \\\"Initializable: contract is already initialized\\\"\\n );\\n _initialized = 1;\\n if (isTopLevelCall) {\\n _initializing = true;\\n }\\n _;\\n if (isTopLevelCall) {\\n _initializing = false;\\n emit Initialized(1);\\n }\\n }\\n\\n /**\\n * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\\n * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\\n * used to initialize parent contracts.\\n *\\n * `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original\\n * initialization step. This is essential to configure modules that are added through upgrades and that require\\n * initialization.\\n *\\n * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\\n * a contract, executing them in the right order is up to the developer or operator.\\n */\\n modifier reinitializer(uint8 version) {\\n require(!_initializing && _initialized < version, \\\"Initializable: contract is already initialized\\\");\\n _initialized = version;\\n _initializing = true;\\n _;\\n _initializing = false;\\n emit Initialized(version);\\n }\\n\\n /**\\n * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\\n * {initializer} and {reinitializer} modifiers, directly or indirectly.\\n */\\n modifier onlyInitializing() {\\n require(_initializing, \\\"Initializable: contract is not initializing\\\");\\n _;\\n }\\n\\n /**\\n * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\\n * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\\n * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\\n * through proxies.\\n */\\n function _disableInitializers() internal virtual {\\n require(!_initializing, \\\"Initializable: contract is initializing\\\");\\n if (_initialized < type(uint8).max) {\\n _initialized = type(uint8).max;\\n emit Initialized(type(uint8).max);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0203dcadc5737d9ef2c211d6fa15d18ebc3b30dfa51903b64870b01a062b0b4e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (proxy/utils/UUPSUpgradeable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../interfaces/draft-IERC1822Upgradeable.sol\\\";\\nimport \\\"../ERC1967/ERC1967UpgradeUpgradeable.sol\\\";\\nimport \\\"./Initializable.sol\\\";\\n\\n/**\\n * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an\\n * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.\\n *\\n * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is\\n * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing\\n * `UUPSUpgradeable` with a custom implementation of upgrades.\\n *\\n * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.\\n *\\n * _Available since v4.1._\\n */\\nabstract contract UUPSUpgradeable is Initializable, IERC1822ProxiableUpgradeable, ERC1967UpgradeUpgradeable {\\n function __UUPSUpgradeable_init() internal onlyInitializing {\\n }\\n\\n function __UUPSUpgradeable_init_unchained() internal onlyInitializing {\\n }\\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment\\n address private immutable __self = address(this);\\n\\n /**\\n * @dev Check that the execution is being performed through a delegatecall call and that the execution context is\\n * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case\\n * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a\\n * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to\\n * fail.\\n */\\n modifier onlyProxy() {\\n require(address(this) != __self, \\\"Function must be called through delegatecall\\\");\\n require(_getImplementation() == __self, \\\"Function must be called through active proxy\\\");\\n _;\\n }\\n\\n /**\\n * @dev Check that the execution is not being performed through a delegate call. This allows a function to be\\n * callable on the implementing contract but not through proxies.\\n */\\n modifier notDelegated() {\\n require(address(this) == __self, \\\"UUPSUpgradeable: must not be called through delegatecall\\\");\\n _;\\n }\\n\\n /**\\n * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the\\n * implementation. It is used to validate that the this implementation remains valid after an upgrade.\\n *\\n * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\\n * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\\n * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.\\n */\\n function proxiableUUID() external view virtual override notDelegated returns (bytes32) {\\n return _IMPLEMENTATION_SLOT;\\n }\\n\\n /**\\n * @dev Upgrade the implementation of the proxy to `newImplementation`.\\n *\\n * Calls {_authorizeUpgrade}.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function upgradeTo(address newImplementation) external virtual onlyProxy {\\n _authorizeUpgrade(newImplementation);\\n _upgradeToAndCallUUPS(newImplementation, new bytes(0), false);\\n }\\n\\n /**\\n * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call\\n * encoded in `data`.\\n *\\n * Calls {_authorizeUpgrade}.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function upgradeToAndCall(address newImplementation, bytes memory data) external payable virtual onlyProxy {\\n _authorizeUpgrade(newImplementation);\\n _upgradeToAndCallUUPS(newImplementation, data, true);\\n }\\n\\n /**\\n * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by\\n * {upgradeTo} and {upgradeToAndCall}.\\n *\\n * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.\\n *\\n * ```solidity\\n * function _authorizeUpgrade(address) internal override onlyOwner {}\\n * ```\\n */\\n function _authorizeUpgrade(address newImplementation) internal virtual;\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x6e36e9b4b71de699c2f3f0d4e4d1aa0b35da99a26e8d5b91ef09ba234b4ef270\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x611aa3f23e59cfdd1863c536776407b3e33d695152a266fa7cfb34440a29a8a3\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StorageSlotUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for reading and writing primitive types to specific storage slots.\\n *\\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\\n * This library helps with reading and writing to such slots without the need for inline assembly.\\n *\\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\\n *\\n * Example usage to set ERC1967 implementation slot:\\n * ```\\n * contract ERC1967 {\\n * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n *\\n * function _getImplementation() internal view returns (address) {\\n * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\\n * }\\n *\\n * function _setImplementation(address newImplementation) internal {\\n * require(Address.isContract(newImplementation), \\\"ERC1967: new implementation is not a contract\\\");\\n * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\\n * }\\n * }\\n * ```\\n *\\n * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._\\n */\\nlibrary StorageSlotUpgradeable {\\n struct AddressSlot {\\n address value;\\n }\\n\\n struct BooleanSlot {\\n bool value;\\n }\\n\\n struct Bytes32Slot {\\n bytes32 value;\\n }\\n\\n struct Uint256Slot {\\n uint256 value;\\n }\\n\\n /**\\n * @dev Returns an `AddressSlot` with member `value` located at `slot`.\\n */\\n function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\\n */\\n function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\\n */\\n function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\\n */\\n function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n}\\n\",\"keccak256\":\"0x09864aea84f01e39313375b5610c73a3c1c68abbdc51e5ccdd25ff977fdadf9a\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/ERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165 is IERC165 {\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165).interfaceId;\\n }\\n}\\n\",\"keccak256\":\"0xd10975de010d89fd1c78dc5e8a9a7e7f496198085c151648f20cba166b32582b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/ERC165Storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165Storage.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./ERC165.sol\\\";\\n\\n/**\\n * @dev Storage based implementation of the {IERC165} interface.\\n *\\n * Contracts may inherit from this and call {_registerInterface} to declare\\n * their support of an interface.\\n */\\nabstract contract ERC165Storage is ERC165 {\\n /**\\n * @dev Mapping of interface ids to whether or not it's supported.\\n */\\n mapping(bytes4 => bool) private _supportedInterfaces;\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return super.supportsInterface(interfaceId) || _supportedInterfaces[interfaceId];\\n }\\n\\n /**\\n * @dev Registers the contract as an implementer of the interface defined by\\n * `interfaceId`. Support of the actual ERC165 interface is automatic and\\n * registering its interface id is not required.\\n *\\n * See {IERC165-supportsInterface}.\\n *\\n * Requirements:\\n *\\n * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).\\n */\\n function _registerInterface(bytes4 interfaceId) internal virtual {\\n require(interfaceId != 0xffffffff, \\\"ERC165: invalid interface id\\\");\\n _supportedInterfaces[interfaceId] = true;\\n }\\n}\\n\",\"keccak256\":\"0x77bf0086774bab931413c3388d3a0f7d44cf6878965b72147f57bb0fbbf394bd\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x447a5f3ddc18419d41ff92b3773fb86471b1db25773e07f877f548918a185bf1\",\"license\":\"MIT\"},\"contracts/GnosisWrapper.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\npragma solidity ^0.8.0;\\n\\nimport \\\"@fractal-framework/core-contracts/contracts/ModuleBase.sol\\\";\\nimport \\\"./IGnosisWrapper.sol\\\";\\n\\ncontract GnosisWrapper is ModuleBase {\\n address public gnosisSafe;\\n\\n function initialize(address _accessControl, address _gnosisSafe)\\n public\\n initializer\\n {\\n __initBase(_accessControl, msg.sender, \\\"Wrapper Module\\\");\\n _registerInterface(type(IGnosisWrapper).interfaceId);\\n gnosisSafe = _gnosisSafe;\\n }\\n}\\n\",\"keccak256\":\"0x9170ce2706b5f2f858077655d0b49e83b438b080be113055ec4fb8a357c91e4a\",\"license\":\"Unlicense\"},\"contracts/IGnosisWrapper.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\npragma solidity ^0.8.0;\\n\\ninterface IGnosisWrapper {\\n function initialize(address _accessControl, address _gnosisSafe) external;\\n function gnosisSafe() external view returns(address);\\n}\\n\",\"keccak256\":\"0xbbe3a9695df8ffc67358a2663cc8c9a4bfdd89566c525191b244398588f3d9f3\",\"license\":\"Unlicense\"}},\"version\":1}", - "bytecode": "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", - "deployedBytecode": "0x6080604052600436106100865760003560e01c8063485cc95511610059578063485cc9551461013c5780634f1ef2861461015c57806352d1902d1461016f5780638991255b14610192578063a84173ae146101b257600080fd5b806301ffc9a71461008b57806306fdde03146100c057806313007d55146100e25780633659cfe61461011a575b600080fd5b34801561009757600080fd5b506100ab6100a6366004610c80565b6101d2565b60405190151581526020015b60405180910390f35b3480156100cc57600080fd5b506100d5610212565b6040516100b79190610cd6565b3480156100ee57600080fd5b50606654610102906001600160a01b031681565b6040516001600160a01b0390911681526020016100b7565b34801561012657600080fd5b5061013a610135366004610d25565b6102a4565b005b34801561014857600080fd5b5061013a610157366004610d40565b61038c565b61013a61016a366004610d89565b6104f3565b34801561017b57600080fd5b506101846105c3565b6040519081526020016100b7565b34801561019e57600080fd5b50606754610102906001600160a01b031681565b3480156101be57600080fd5b50606954610102906001600160a01b031681565b60006301ffc9a760e01b6001600160e01b03198316148061020c57506001600160e01b0319821660009081526065602052604090205460ff165b92915050565b60606068805461022190610e4b565b80601f016020809104026020016040519081016040528092919081815260200182805461024d90610e4b565b801561029a5780601f1061026f5761010080835404028352916020019161029a565b820191906000526020600020905b81548152906001019060200180831161027d57829003601f168201915b5050505050905090565b6001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001630036102f55760405162461bcd60e51b81526004016102ec90610e85565b60405180910390fd5b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031661033e600080516020610fc0833981519152546001600160a01b031690565b6001600160a01b0316146103645760405162461bcd60e51b81526004016102ec90610ed1565b61036d81610676565b604080516000808252602082019092526103899183919061071a565b50565b600054610100900460ff16158080156103ac5750600054600160ff909116105b806103c65750303b1580156103c6575060005460ff166001145b6104295760405162461bcd60e51b815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201526d191e481a5b9a5d1a585b1a5e995960921b60648201526084016102ec565b6000805460ff19166001179055801561044c576000805461ff0019166101001790555b61047d83336040518060400160405280600e81526020016d57726170706572204d6f64756c6560901b815250610885565b61048d63e01dbafb60e01b610904565b606980546001600160a01b0319166001600160a01b03841617905580156104ee576000805461ff0019169055604051600181527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a15b505050565b6001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016300361053b5760405162461bcd60e51b81526004016102ec90610e85565b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316610584600080516020610fc0833981519152546001600160a01b031690565b6001600160a01b0316146105aa5760405162461bcd60e51b81526004016102ec90610ed1565b6105b382610676565b6105bf8282600161071a565b5050565b6000306001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016146106635760405162461bcd60e51b815260206004820152603860248201527f555550535570677261646561626c653a206d757374206e6f742062652063616c60448201527f6c6564207468726f7567682064656c656761746563616c6c000000000000000060648201526084016102ec565b50600080516020610fc083398151915290565b6066546040516001623b410b60e21b031981523360048201523060248201526000356001600160e01b03191660448201526001600160a01b039091169063ff12fbd490606401602060405180830381865afa1580156106d9573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906106fd9190610f1d565b6103895760405163ea8e4eb560e01b815260040160405180910390fd5b7f4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd91435460ff161561074d576104ee83610983565b826001600160a01b03166352d1902d6040518163ffffffff1660e01b8152600401602060405180830381865afa9250505080156107a7575060408051601f3d908101601f191682019092526107a491810190610f3f565b60015b61080a5760405162461bcd60e51b815260206004820152602e60248201527f45524331393637557067726164653a206e657720696d706c656d656e7461746960448201526d6f6e206973206e6f74205555505360901b60648201526084016102ec565b600080516020610fc083398151915281146108795760405162461bcd60e51b815260206004820152602960248201527f45524331393637557067726164653a20756e737570706f727465642070726f786044820152681a58589b195555525160ba1b60648201526084016102ec565b506104ee838383610a1f565b600054610100900460ff166108ac5760405162461bcd60e51b81526004016102ec90610f58565b606680546001600160a01b038086166001600160a01b031992831617909255606780549285169290911691909117905580516108ef906068906020840190610be7565b506108f8610a4a565b6104ee630afed1ab60e11b5b6001600160e01b0319808216900361095e5760405162461bcd60e51b815260206004820152601c60248201527f4552433136353a20696e76616c696420696e746572666163652069640000000060448201526064016102ec565b6001600160e01b0319166000908152606560205260409020805460ff19166001179055565b6001600160a01b0381163b6109f05760405162461bcd60e51b815260206004820152602d60248201527f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60448201526c1bdd08184818dbdb9d1c9858dd609a1b60648201526084016102ec565b600080516020610fc083398151915280546001600160a01b0319166001600160a01b0392909216919091179055565b610a2883610a73565b600082511180610a355750805b156104ee57610a448383610ab3565b50505050565b600054610100900460ff16610a715760405162461bcd60e51b81526004016102ec90610f58565b565b610a7c81610983565b6040516001600160a01b038216907fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b90600090a250565b60606001600160a01b0383163b610b1b5760405162461bcd60e51b815260206004820152602660248201527f416464726573733a2064656c65676174652063616c6c20746f206e6f6e2d636f6044820152651b9d1c9858dd60d21b60648201526084016102ec565b600080846001600160a01b031684604051610b369190610fa3565b600060405180830381855af49150503d8060008114610b71576040519150601f19603f3d011682016040523d82523d6000602084013e610b76565b606091505b5091509150610b9e8282604051806060016040528060278152602001610fe060279139610ba7565b95945050505050565b60608315610bb6575081610be0565b825115610bc65782518084602001fd5b8160405162461bcd60e51b81526004016102ec9190610cd6565b9392505050565b828054610bf390610e4b565b90600052602060002090601f016020900481019282610c155760008555610c5b565b82601f10610c2e57805160ff1916838001178555610c5b565b82800160010185558215610c5b579182015b82811115610c5b578251825591602001919060010190610c40565b50610c67929150610c6b565b5090565b5b80821115610c675760008155600101610c6c565b600060208284031215610c9257600080fd5b81356001600160e01b031981168114610be057600080fd5b60005b83811015610cc5578181015183820152602001610cad565b83811115610a445750506000910152565b6020815260008251806020840152610cf5816040850160208701610caa565b601f01601f19169190910160400192915050565b80356001600160a01b0381168114610d2057600080fd5b919050565b600060208284031215610d3757600080fd5b610be082610d09565b60008060408385031215610d5357600080fd5b610d5c83610d09565b9150610d6a60208401610d09565b90509250929050565b634e487b7160e01b600052604160045260246000fd5b60008060408385031215610d9c57600080fd5b610da583610d09565b9150602083013567ffffffffffffffff80821115610dc257600080fd5b818501915085601f830112610dd657600080fd5b813581811115610de857610de8610d73565b604051601f8201601f19908116603f01168101908382118183101715610e1057610e10610d73565b81604052828152886020848701011115610e2957600080fd5b8260208601602083013760006020848301015280955050505050509250929050565b600181811c90821680610e5f57607f821691505b602082108103610e7f57634e487b7160e01b600052602260045260246000fd5b50919050565b6020808252602c908201527f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060408201526b19195b1959d85d1958d85b1b60a21b606082015260800190565b6020808252602c908201527f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060408201526b6163746976652070726f787960a01b606082015260800190565b600060208284031215610f2f57600080fd5b81518015158114610be057600080fd5b600060208284031215610f5157600080fd5b5051919050565b6020808252602b908201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960408201526a6e697469616c697a696e6760a81b606082015260800190565b60008251610fb5818460208701610caa565b919091019291505056fe360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a264697066735822122004917fd576d3baa2c92eaf2bbc16ff98b646f6ac38c94d30f11f5aafb59bc9e764736f6c634300080d0033", - "devdoc": { - "kind": "dev", - "methods": { - "name()": { - "returns": { - "_0": "The module name" - } - }, - "proxiableUUID()": { - "details": "Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the implementation. It is used to validate that the this implementation remains valid after an upgrade. IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier." - }, - "supportsInterface(bytes4)": { - "details": "See {IERC165-supportsInterface}." - }, - "upgradeTo(address)": { - "details": "Upgrade the implementation of the proxy to `newImplementation`. Calls {_authorizeUpgrade}. Emits an {Upgraded} event." - }, - "upgradeToAndCall(address,bytes)": { - "details": "Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call encoded in `data`. Calls {_authorizeUpgrade}. Emits an {Upgraded} event." - } - }, - "version": 1 - }, - "userdoc": { - "kind": "user", - "methods": { - "name()": { - "notice": "Returns the module name" - } - }, - "version": 1 - }, - "storageLayout": { - "storage": [ - { - "astId": 2427, - "contract": "contracts/GnosisWrapper.sol:GnosisWrapper", - "label": "_initialized", - "offset": 0, - "slot": "0", - "type": "t_uint8" - }, - { - "astId": 2430, - "contract": "contracts/GnosisWrapper.sol:GnosisWrapper", - "label": "_initializing", - "offset": 1, - "slot": "0", - "type": "t_bool" - }, - { - "astId": 2409, - "contract": "contracts/GnosisWrapper.sol:GnosisWrapper", - "label": "__gap", - "offset": 0, - "slot": "1", - "type": "t_array(t_uint256)50_storage" - }, - { - "astId": 2706, - "contract": "contracts/GnosisWrapper.sol:GnosisWrapper", - "label": "__gap", - "offset": 0, - "slot": "51", - "type": "t_array(t_uint256)50_storage" - }, - { - "astId": 4073, - "contract": "contracts/GnosisWrapper.sol:GnosisWrapper", - "label": "_supportedInterfaces", - "offset": 0, - "slot": "101", - "type": "t_mapping(t_bytes4,t_bool)" - }, - { - "astId": 1411, - "contract": "contracts/GnosisWrapper.sol:GnosisWrapper", - "label": "accessControl", - "offset": 0, - "slot": "102", - "type": "t_contract(IDAOAccessControl)1841" - }, - { - "astId": 1413, - "contract": "contracts/GnosisWrapper.sol:GnosisWrapper", - "label": "moduleFactory", - "offset": 0, - "slot": "103", - "type": "t_address" - }, - { - "astId": 1415, - "contract": "contracts/GnosisWrapper.sol:GnosisWrapper", - "label": "_name", - "offset": 0, - "slot": "104", - "type": "t_string_storage" - }, - { - "astId": 4133, - "contract": "contracts/GnosisWrapper.sol:GnosisWrapper", - "label": "gnosisSafe", - "offset": 0, - "slot": "105", - "type": "t_address" - } - ], - "types": { - "t_address": { - "encoding": "inplace", - "label": "address", - "numberOfBytes": "20" - }, - "t_array(t_uint256)50_storage": { - "base": "t_uint256", - "encoding": "inplace", - "label": "uint256[50]", - "numberOfBytes": "1600" - }, - "t_bool": { - "encoding": "inplace", - "label": "bool", - "numberOfBytes": "1" - }, - "t_bytes4": { - "encoding": "inplace", - "label": "bytes4", - "numberOfBytes": "4" - }, - "t_contract(IDAOAccessControl)1841": { - "encoding": "inplace", - "label": "contract IDAOAccessControl", - "numberOfBytes": "20" - }, - "t_mapping(t_bytes4,t_bool)": { - "encoding": "mapping", - "key": "t_bytes4", - "label": "mapping(bytes4 => bool)", - "numberOfBytes": "32", - "value": "t_bool" - }, - "t_string_storage": { - "encoding": "bytes", - "label": "string", - "numberOfBytes": "32" - }, - "t_uint256": { - "encoding": "inplace", - "label": "uint256", - "numberOfBytes": "32" - }, - "t_uint8": { - "encoding": "inplace", - "label": "uint8", - "numberOfBytes": "1" - } - } - } -} \ No newline at end of file diff --git a/deployments/rinkeby/GnosisWrapperFactory.json b/deployments/rinkeby/GnosisWrapperFactory.json deleted file mode 100644 index 21149b97..00000000 --- a/deployments/rinkeby/GnosisWrapperFactory.json +++ /dev/null @@ -1,404 +0,0 @@ -{ - "address": "0xD751e9dAa21fA93c39bE095Fb76b69C8D62A6368", - "abi": [ - { - "anonymous": false, - "inputs": [ - { - "indexed": false, - "internalType": "address", - "name": "gnosisSafe", - "type": "address" - } - ], - "name": "GnosisWrapperCreated", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": false, - "internalType": "uint8", - "name": "version", - "type": "uint8" - } - ], - "name": "Initialized", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": true, - "internalType": "address", - "name": "previousOwner", - "type": "address" - }, - { - "indexed": true, - "internalType": "address", - "name": "newOwner", - "type": "address" - } - ], - "name": "OwnershipTransferred", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": false, - "internalType": "string", - "name": "semanticVersion", - "type": "string" - }, - { - "indexed": false, - "internalType": "string", - "name": "frontendURI", - "type": "string" - }, - { - "indexed": false, - "internalType": "address", - "name": "impl", - "type": "address" - } - ], - "name": "VersionCreated", - "type": "event" - }, - { - "inputs": [ - { - "internalType": "string", - "name": "_semanticVersion", - "type": "string" - }, - { - "internalType": "string", - "name": "_frontendURI", - "type": "string" - }, - { - "internalType": "address", - "name": "_impl", - "type": "address" - } - ], - "name": "addVersion", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "creator", - "type": "address" - }, - { - "internalType": "bytes[]", - "name": "data", - "type": "bytes[]" - } - ], - "name": "create", - "outputs": [ - { - "internalType": "address[]", - "name": "", - "type": "address[]" - } - ], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [], - "name": "initialize", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [], - "name": "owner", - "outputs": [ - { - "internalType": "address", - "name": "", - "type": "address" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [], - "name": "renounceOwnership", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "bytes4", - "name": "interfaceId", - "type": "bytes4" - } - ], - "name": "supportsInterface", - "outputs": [ - { - "internalType": "bool", - "name": "", - "type": "bool" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "newOwner", - "type": "address" - } - ], - "name": "transferOwnership", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "uint256", - "name": "", - "type": "uint256" - } - ], - "name": "versionControl", - "outputs": [ - { - "internalType": "string", - "name": "semanticVersion", - "type": "string" - }, - { - "internalType": "string", - "name": "frontendURI", - "type": "string" - }, - { - "internalType": "address", - "name": "impl", - "type": "address" - } - ], - "stateMutability": "view", - "type": "function" - } - ], - "transactionHash": "0xdfbee9bce5b40b3f3c19822a519965de63542f3661aa60a2a38f598641f8e5bb", - "receipt": { - "to": null, - "from": "0x629750317d320B8bB4d48D345A6d699Cc855c4a6", - "contractAddress": "0xD751e9dAa21fA93c39bE095Fb76b69C8D62A6368", - "transactionIndex": 33, - "gasUsed": "1467659", - "logsBloom": "0x00000000000000000000000000000000000000000010000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000020000000000000000000800000000000000000000000000000000400000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000020002000000000002000000000000000000000000000000000000000000000020000000000000000000000000000000000000000001000000000000000000000000", - "blockHash": "0x5b3bb706aba45e0101032b94e9757362436b9bcadc44f26a1a47766fe68dcfd7", - "transactionHash": "0xdfbee9bce5b40b3f3c19822a519965de63542f3661aa60a2a38f598641f8e5bb", - "logs": [ - { - "transactionIndex": 33, - "blockNumber": 11255777, - "transactionHash": "0xdfbee9bce5b40b3f3c19822a519965de63542f3661aa60a2a38f598641f8e5bb", - "address": "0xD751e9dAa21fA93c39bE095Fb76b69C8D62A6368", - "topics": [ - "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x000000000000000000000000629750317d320b8bb4d48d345a6d699cc855c4a6" - ], - "data": "0x", - "logIndex": 133, - "blockHash": "0x5b3bb706aba45e0101032b94e9757362436b9bcadc44f26a1a47766fe68dcfd7" - } - ], - "blockNumber": 11255777, - "cumulativeGasUsed": "5827842", - "status": 1, - "byzantium": true - }, - "args": [], - "numDeployments": 1, - "solcInputHash": "6e6f9d675593c08f2cd8ae1cedebec27", - "metadata": "{\"compiler\":{\"version\":\"0.8.13+commit.abaa5c0e\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"gnosisSafe\",\"type\":\"address\"}],\"name\":\"GnosisWrapperCreated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"semanticVersion\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"frontendURI\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"impl\",\"type\":\"address\"}],\"name\":\"VersionCreated\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"_semanticVersion\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"_frontendURI\",\"type\":\"string\"},{\"internalType\":\"address\",\"name\":\"_impl\",\"type\":\"address\"}],\"name\":\"addVersion\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"creator\",\"type\":\"address\"},{\"internalType\":\"bytes[]\",\"name\":\"data\",\"type\":\"bytes[]\"}],\"name\":\"create\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"\",\"type\":\"address[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"versionControl\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"semanticVersion\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"frontendURI\",\"type\":\"string\"},{\"internalType\":\"address\",\"name\":\"impl\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"details\":\"GnosisWrapper Factory used to deploy Gnosis Modules\",\"kind\":\"dev\",\"methods\":{\"addVersion(string,string,address)\":{\"details\":\"add a new version to update module users\",\"params\":{\"_frontendURI\":\"IPFS hash of the static frontend\",\"_impl\":\"address of the impl\",\"_semanticVersion\":\"semantic version control\"}},\"create(address,bytes[])\":{\"details\":\"Creates a GnosisWrapper module\",\"params\":{\"creator\":\"The address creating the module\",\"data\":\"The array of bytes used to create the module\"},\"returns\":{\"_0\":\"address[] The array of addresses of the created module\"}},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner.\"},\"supportsInterface(bytes4)\":{\"details\":\"See {IERC165-supportsInterface}.\"},\"transferOwnership(address)\":{\"details\":\"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/GnosisWrapperFactory.sol\":\"GnosisWrapperFactory\"},\"evmVersion\":\"london\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@fractal-framework/core-contracts/contracts/ModuleBase.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\\\";\\r\\nimport \\\"@openzeppelin/contracts/utils/introspection/ERC165Storage.sol\\\";\\r\\nimport \\\"./interfaces/IModuleBase.sol\\\";\\r\\n\\r\\n/// @notice An abstract contract to be inherited by module contracts\\r\\nabstract contract ModuleBase is IModuleBase, UUPSUpgradeable, ERC165Storage {\\r\\n IDAOAccessControl public accessControl;\\r\\n address public moduleFactory;\\r\\n string internal _name;\\r\\n\\r\\n /// @notice Requires that a function caller has the associated role\\r\\n modifier authorized() {\\r\\n if (\\r\\n !accessControl.actionIsAuthorized(\\r\\n msg.sender,\\r\\n address(this),\\r\\n msg.sig\\r\\n )\\r\\n ) {\\r\\n revert NotAuthorized();\\r\\n }\\r\\n _;\\r\\n }\\r\\n\\r\\n /// @notice Function for initializing the contract that can only be called once\\r\\n /// @param _accessControl The address of the access control contract\\r\\n /// @param _moduleFactory The address of the factory deploying the module\\r\\n /// @param __name Human readable string of the module name\\r\\n function __initBase(address _accessControl, address _moduleFactory, string memory __name)\\r\\n internal\\r\\n onlyInitializing\\r\\n {\\r\\n accessControl = IDAOAccessControl(_accessControl);\\r\\n moduleFactory = _moduleFactory;\\r\\n _name = __name;\\r\\n __UUPSUpgradeable_init();\\r\\n _registerInterface(type(IModuleBase).interfaceId);\\r\\n }\\r\\n\\r\\n /// @dev Applies authorized modifier so that an upgrade require the caller to have the correct role\\r\\n /// @param newImplementation The address of the new implementation contract being upgraded to\\r\\n function _authorizeUpgrade(address newImplementation)\\r\\n internal\\r\\n override\\r\\n authorized\\r\\n {}\\r\\n\\r\\n /// @notice Returns the module name\\r\\n /// @return The module name\\r\\n function name() public view virtual returns (string memory) {\\r\\n return _name;\\r\\n }\\r\\n}\\r\\n\",\"keccak256\":\"0xdd4b440c6924fe479e6e3c72e35d109c3af3a9eeb72eab85c65bbe31a2b05dcf\",\"license\":\"Unlicense\"},\"@fractal-framework/core-contracts/contracts/ModuleFactoryBase.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\r\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\\\";\\r\\nimport \\\"@openzeppelin/contracts/utils/introspection/ERC165Storage.sol\\\";\\r\\nimport \\\"./interfaces/IModuleFactoryBase.sol\\\";\\r\\n\\r\\n/// @notice An abstract contract to be inherited by module contracts\\r\\nabstract contract ModuleFactoryBase is\\r\\n IModuleFactoryBase,\\r\\n Ownable,\\r\\n Initializable,\\r\\n ERC165Storage\\r\\n{\\r\\n VersionInfo[] public versionControl;\\r\\n\\r\\n /// @dev add a new version to update module users\\r\\n /// @param _semanticVersion semantic version control\\r\\n /// @param _frontendURI IPFS hash of the static frontend\\r\\n /// @param _impl address of the impl\\r\\n function addVersion(\\r\\n string calldata _semanticVersion,\\r\\n string calldata _frontendURI,\\r\\n address _impl\\r\\n ) external onlyOwner {\\r\\n versionControl.push(VersionInfo(_semanticVersion, _frontendURI, _impl));\\r\\n emit VersionCreated(_semanticVersion, _frontendURI, _impl);\\r\\n }\\r\\n\\r\\n /// @dev Creates a module\\r\\n /// @param creator The address creating the module\\r\\n /// @param data The array of bytes used to create the module\\r\\n /// @return address[] Array of the created module addresses\\r\\n function create(address creator, bytes[] calldata data)\\r\\n external\\r\\n virtual\\r\\n returns (address[] memory);\\r\\n\\r\\n /// @notice Function for initializing the contract that can only be called once\\r\\n function __initFactoryBase() internal onlyInitializing {\\r\\n _registerInterface(type(IModuleFactoryBase).interfaceId);\\r\\n }\\r\\n}\\r\\n\",\"keccak256\":\"0x0720f0e7ad48db40d88974112914d7c374c8e6309285b14a29c53a4a5412b0f2\",\"license\":\"Unlicense\"},\"@fractal-framework/core-contracts/contracts/interfaces/IDAOAccessControl.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\ninterface IDAOAccessControl {\\r\\n struct RoleData {\\r\\n mapping(address => bool) members;\\r\\n string adminRole;\\r\\n }\\r\\n\\r\\n error UnequalArrayLengths();\\r\\n error MissingRole(address account, string role);\\r\\n error OnlySelfRenounce();\\r\\n\\r\\n event ActionRoleAdded(\\r\\n address target,\\r\\n string functionDesc,\\r\\n bytes4 encodedSig,\\r\\n string role\\r\\n );\\r\\n event ActionRoleRemoved(\\r\\n address target,\\r\\n string functionDesc,\\r\\n bytes4 encodedSig,\\r\\n string role\\r\\n );\\r\\n event RoleAdminChanged(\\r\\n string role,\\r\\n string previousAdminRole,\\r\\n string adminRole\\r\\n );\\r\\n event RoleGranted(string role, address account, address admin);\\r\\n event RoleRevoked(string role, address account, address admin);\\r\\n\\r\\n /// @notice Initialize DAO action and role permissions\\r\\n /// @param dao Address to receive DAO role\\r\\n /// @param roles What permissions are assigned to\\r\\n /// @param roleAdmins Roles which have the ability to remove or add members\\r\\n /// @param members Addresses to be granted the specified roles\\r\\n /// @param targets Contract addresses for actions to be defined on\\r\\n /// @param functionDescs Function descriptions used to define actions\\r\\n /// @param actionRoles Roles being granted permission for an action\\r\\n function initialize(\\r\\n address dao,\\r\\n string[] memory roles,\\r\\n string[] memory roleAdmins,\\r\\n address[][] memory members,\\r\\n address[] memory targets,\\r\\n string[] memory functionDescs,\\r\\n string[][] memory actionRoles\\r\\n ) external;\\r\\n\\r\\n /// @notice Grants roles to the specified addresses and defines admin roles\\r\\n /// @notice This function can only be called by the DAO\\r\\n /// @param roles The roles being granted\\r\\n /// @param roleAdmins The roles being granted as admins of the specified of roles\\r\\n /// @param members Addresses being granted each specified role\\r\\n function daoGrantRolesAndAdmins(\\r\\n string[] memory roles,\\r\\n string[] memory roleAdmins,\\r\\n address[][] memory members\\r\\n ) external;\\r\\n\\r\\n /// @notice Grants roles to the specified addresses\\r\\n /// @notice This function can only be called by the DAO\\r\\n /// @param roles The roles being granted\\r\\n /// @param members Addresses being granted each specified role\\r\\n function daoGrantRoles(string[] memory roles, address[][] memory members)\\r\\n external;\\r\\n\\r\\n /// @notice Authorizes roles to execute the specified actions\\r\\n /// @notice This function can only be called by the DAO\\r\\n /// @param targets The contract addresses that the action functions are implemented on\\r\\n /// @param functionDescs The function descriptions used to define the actions\\r\\n /// @param roles Roles being granted permission for an action\\r\\n function daoAddActionsRoles(\\r\\n address[] memory targets,\\r\\n string[] memory functionDescs,\\r\\n string[][] memory roles\\r\\n ) external;\\r\\n\\r\\n /// @notice Removes autorization for roles to execute the specified actions\\r\\n /// @notice This function can only be called by the DAO\\r\\n /// @param targets The contract addresses that the action functions are implemented on\\r\\n /// @param functionDescs The function description used to define the actions\\r\\n /// @param roles Roles that action permissions are being removed on\\r\\n function daoRemoveActionsRoles(\\r\\n address[] memory targets,\\r\\n string[] memory functionDescs,\\r\\n string[][] memory roles\\r\\n ) external;\\r\\n\\r\\n /// @notice Grants a role to the specified address\\r\\n /// @notice This function can only be called by an admin of the specified role\\r\\n /// @param role The role being granted\\r\\n /// @param account The address being granted the specified role\\r\\n function adminGrantRole(string memory role, address account)\\r\\n external;\\r\\n\\r\\n /// @notice Revokes a role from the specified address\\r\\n /// @notice This function can only be called by an admin of the specified role\\r\\n /// @param role The role being revoked\\r\\n /// @param account The address the role is being revoked from\\r\\n function adminRevokeRole(string memory role, address account)\\r\\n external;\\r\\n\\r\\n /// @notice Enables an address to remove one of its own roles\\r\\n /// @notice This function can only be called by the account specified\\r\\n /// @param role The role being renounced\\r\\n /// @param account The address renouncing the role\\r\\n function userRenounceRole(string memory role, address account) external;\\r\\n\\r\\n /// @notice Checks if a caller has the permissions to execute the specific action\\r\\n /// @param caller Address attempting to execute the action\\r\\n /// @param target Contract address corresponding to the action\\r\\n /// @param sig The function signature used to define the action\\r\\n function actionIsAuthorized(\\r\\n address caller,\\r\\n address target,\\r\\n bytes4 sig\\r\\n ) external view returns (bool isAuthorized);\\r\\n\\r\\n /// @notice Returns the roles autorized to execute the specified action\\r\\n /// @param target Contract address corresponding to the action\\r\\n /// @param functionDesc The function description used to define the action\\r\\n function getActionRoles(address target, string memory functionDesc)\\r\\n external\\r\\n view\\r\\n returns (string[] memory roles);\\r\\n\\r\\n /// @notice Checks if a specific role is authorized for an action\\r\\n /// @param role Role that authorization is being checked on\\r\\n /// @param target Contract address corresponding to the action\\r\\n /// @param functionDesc Function description used to define the action\\r\\n /// @return isAuthorized Indicates whether the role is authorized to execute the action\\r\\n function isRoleAuthorized(\\r\\n string calldata role,\\r\\n address target,\\r\\n string memory functionDesc\\r\\n ) external view returns (bool isAuthorized);\\r\\n\\r\\n /// @notice Returns whether the account has been granted the role\\r\\n /// @param role Role that authorization is being checked on\\r\\n /// @param account Address that the role authorization is being check on\\r\\n /// @return boolean Indicates whether the address has been granted the role\\r\\n function hasRole(string memory role, address account)\\r\\n external\\r\\n view\\r\\n returns (bool);\\r\\n\\r\\n /// @notice Returns the role that is the admin of the specified role\\r\\n /// @param role Role that the admin role is being returned for\\r\\n /// @return string The admin role of the specified role\\r\\n function getRoleAdmin(string memory role)\\r\\n external\\r\\n view\\r\\n returns (string memory);\\r\\n\\r\\n /// @return string The string \\\"DAO_ROLE\\\"\\r\\n function DAO_ROLE() external view returns (string memory);\\r\\n}\\r\\n\",\"keccak256\":\"0x8862f578b4fe6a79370b5cbe896e59df4722e95dbb1b0d2e286e335915ed616c\",\"license\":\"Unlicense\"},\"@fractal-framework/core-contracts/contracts/interfaces/IModuleBase.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\nimport \\\"./IDAOAccessControl.sol\\\";\\r\\n\\r\\ninterface IModuleBase {\\r\\n error NotAuthorized();\\r\\n\\r\\n /// @return IDAOAccessControl The Access control interface\\r\\n function accessControl() external view returns (IDAOAccessControl);\\r\\n\\r\\n /// @return string The string \\\"Name\\\"\\r\\n function name() external view returns (string memory);\\r\\n}\\r\\n\",\"keccak256\":\"0xf7aa0a6fc64e3ea68e1fe799390408e62bfd9d1339d6c31c6d862f3af158cca6\",\"license\":\"Unlicense\"},\"@fractal-framework/core-contracts/contracts/interfaces/IModuleFactoryBase.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\n/// @dev The interface to be inherited by Fractal module factories\\r\\ninterface IModuleFactoryBase {\\r\\n event VersionCreated(\\r\\n string semanticVersion,\\r\\n string frontendURI,\\r\\n address impl\\r\\n );\\r\\n struct VersionInfo {\\r\\n string semanticVersion;\\r\\n string frontendURI;\\r\\n address impl;\\r\\n }\\r\\n\\r\\n /// @dev add a new version to update module users\\r\\n /// @param _semanticVersion semantic version control\\r\\n /// @param _frontendURI IPFS hash of the static frontend\\r\\n /// @param _impl address of the impl\\r\\n function addVersion(\\r\\n string calldata _semanticVersion,\\r\\n string calldata _frontendURI,\\r\\n address _impl\\r\\n ) external;\\r\\n\\r\\n /// @dev Creates a module\\r\\n /// @param creator The address creating the module\\r\\n /// @param data The array of bytes used to create the module\\r\\n /// @return address[] Array of the created module addresses\\r\\n function create(address creator, bytes[] calldata data)\\r\\n external\\r\\n returns (address[] memory);\\r\\n}\\r\\n\",\"keccak256\":\"0xefce9f923254a93b1d9d81c56461c04eaf80bc25a741031119562b42a366a049\",\"license\":\"Unlicense\"},\"@openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified\\n * proxy whose upgrades are fully controlled by the current implementation.\\n */\\ninterface IERC1822ProxiableUpgradeable {\\n /**\\n * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation\\n * address.\\n *\\n * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\\n * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\\n * function revert if invoked through a proxy.\\n */\\n function proxiableUUID() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0x77c89f893e403efc6929ba842b7ccf6534d4ffe03afe31670b4a528c0ad78c0f\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/ERC1967/ERC1967UpgradeUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../beacon/IBeaconUpgradeable.sol\\\";\\nimport \\\"../../interfaces/draft-IERC1822Upgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/StorageSlotUpgradeable.sol\\\";\\nimport \\\"../utils/Initializable.sol\\\";\\n\\n/**\\n * @dev This abstract contract provides getters and event emitting update functions for\\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.\\n *\\n * _Available since v4.1._\\n *\\n * @custom:oz-upgrades-unsafe-allow delegatecall\\n */\\nabstract contract ERC1967UpgradeUpgradeable is Initializable {\\n function __ERC1967Upgrade_init() internal onlyInitializing {\\n }\\n\\n function __ERC1967Upgrade_init_unchained() internal onlyInitializing {\\n }\\n // This is the keccak-256 hash of \\\"eip1967.proxy.rollback\\\" subtracted by 1\\n bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;\\n\\n /**\\n * @dev Storage slot with the address of the current implementation.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.implementation\\\" subtracted by 1, and is\\n * validated in the constructor.\\n */\\n bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n /**\\n * @dev Emitted when the implementation is upgraded.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function _getImplementation() internal view returns (address) {\\n return StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new address in the EIP1967 implementation slot.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(AddressUpgradeable.isContract(newImplementation), \\\"ERC1967: new implementation is not a contract\\\");\\n StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\\n }\\n\\n /**\\n * @dev Perform implementation upgrade\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeTo(address newImplementation) internal {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Perform implementation upgrade with additional setup call.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeToAndCall(\\n address newImplementation,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n _upgradeTo(newImplementation);\\n if (data.length > 0 || forceCall) {\\n _functionDelegateCall(newImplementation, data);\\n }\\n }\\n\\n /**\\n * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeToAndCallUUPS(\\n address newImplementation,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n // Upgrades from old implementations will perform a rollback test. This test requires the new\\n // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing\\n // this special case will break upgrade paths from old UUPS implementation to new ones.\\n if (StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT).value) {\\n _setImplementation(newImplementation);\\n } else {\\n try IERC1822ProxiableUpgradeable(newImplementation).proxiableUUID() returns (bytes32 slot) {\\n require(slot == _IMPLEMENTATION_SLOT, \\\"ERC1967Upgrade: unsupported proxiableUUID\\\");\\n } catch {\\n revert(\\\"ERC1967Upgrade: new implementation is not UUPS\\\");\\n }\\n _upgradeToAndCall(newImplementation, data, forceCall);\\n }\\n }\\n\\n /**\\n * @dev Storage slot with the admin of the contract.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.admin\\\" subtracted by 1, and is\\n * validated in the constructor.\\n */\\n bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\\n\\n /**\\n * @dev Emitted when the admin account has changed.\\n */\\n event AdminChanged(address previousAdmin, address newAdmin);\\n\\n /**\\n * @dev Returns the current admin.\\n */\\n function _getAdmin() internal view returns (address) {\\n return StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new address in the EIP1967 admin slot.\\n */\\n function _setAdmin(address newAdmin) private {\\n require(newAdmin != address(0), \\\"ERC1967: new admin is the zero address\\\");\\n StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value = newAdmin;\\n }\\n\\n /**\\n * @dev Changes the admin of the proxy.\\n *\\n * Emits an {AdminChanged} event.\\n */\\n function _changeAdmin(address newAdmin) internal {\\n emit AdminChanged(_getAdmin(), newAdmin);\\n _setAdmin(newAdmin);\\n }\\n\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Emitted when the beacon is upgraded.\\n */\\n event BeaconUpgraded(address indexed beacon);\\n\\n /**\\n * @dev Returns the current beacon.\\n */\\n function _getBeacon() internal view returns (address) {\\n return StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new beacon in the EIP1967 beacon slot.\\n */\\n function _setBeacon(address newBeacon) private {\\n require(AddressUpgradeable.isContract(newBeacon), \\\"ERC1967: new beacon is not a contract\\\");\\n require(\\n AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()),\\n \\\"ERC1967: beacon implementation is not a contract\\\"\\n );\\n StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value = newBeacon;\\n }\\n\\n /**\\n * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does\\n * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).\\n *\\n * Emits a {BeaconUpgraded} event.\\n */\\n function _upgradeBeaconToAndCall(\\n address newBeacon,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n _setBeacon(newBeacon);\\n emit BeaconUpgraded(newBeacon);\\n if (data.length > 0 || forceCall) {\\n _functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data);\\n }\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function _functionDelegateCall(address target, bytes memory data) private returns (bytes memory) {\\n require(AddressUpgradeable.isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return AddressUpgradeable.verifyCallResult(success, returndata, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x315887e846f1e5f8d8fa535a229d318bb9290aaa69485117f1ee8a9a6b3be823\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/beacon/IBeaconUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeaconUpgradeable {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x24b86ac8c005b8c654fbf6ac34a5a4f61580d7273541e83e013e89d66fbf0908\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\\n * reused. This mechanism prevents re-execution of each \\\"step\\\" but allows the creation of new initialization steps in\\n * case an upgrade adds a module that needs to be initialized.\\n *\\n * For example:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * contract MyToken is ERC20Upgradeable {\\n * function initialize() initializer public {\\n * __ERC20_init(\\\"MyToken\\\", \\\"MTK\\\");\\n * }\\n * }\\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\\n * function initializeV2() reinitializer(2) public {\\n * __ERC20Permit_init(\\\"MyToken\\\");\\n * }\\n * }\\n * ```\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n *\\n * [CAUTION]\\n * ====\\n * Avoid leaving a contract uninitialized.\\n *\\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * /// @custom:oz-upgrades-unsafe-allow constructor\\n * constructor() {\\n * _disableInitializers();\\n * }\\n * ```\\n * ====\\n */\\nabstract contract Initializable {\\n /**\\n * @dev Indicates that the contract has been initialized.\\n * @custom:oz-retyped-from bool\\n */\\n uint8 private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Triggered when the contract has been initialized or reinitialized.\\n */\\n event Initialized(uint8 version);\\n\\n /**\\n * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\\n * `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`.\\n */\\n modifier initializer() {\\n bool isTopLevelCall = !_initializing;\\n require(\\n (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\\n \\\"Initializable: contract is already initialized\\\"\\n );\\n _initialized = 1;\\n if (isTopLevelCall) {\\n _initializing = true;\\n }\\n _;\\n if (isTopLevelCall) {\\n _initializing = false;\\n emit Initialized(1);\\n }\\n }\\n\\n /**\\n * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\\n * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\\n * used to initialize parent contracts.\\n *\\n * `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original\\n * initialization step. This is essential to configure modules that are added through upgrades and that require\\n * initialization.\\n *\\n * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\\n * a contract, executing them in the right order is up to the developer or operator.\\n */\\n modifier reinitializer(uint8 version) {\\n require(!_initializing && _initialized < version, \\\"Initializable: contract is already initialized\\\");\\n _initialized = version;\\n _initializing = true;\\n _;\\n _initializing = false;\\n emit Initialized(version);\\n }\\n\\n /**\\n * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\\n * {initializer} and {reinitializer} modifiers, directly or indirectly.\\n */\\n modifier onlyInitializing() {\\n require(_initializing, \\\"Initializable: contract is not initializing\\\");\\n _;\\n }\\n\\n /**\\n * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\\n * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\\n * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\\n * through proxies.\\n */\\n function _disableInitializers() internal virtual {\\n require(!_initializing, \\\"Initializable: contract is initializing\\\");\\n if (_initialized < type(uint8).max) {\\n _initialized = type(uint8).max;\\n emit Initialized(type(uint8).max);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0203dcadc5737d9ef2c211d6fa15d18ebc3b30dfa51903b64870b01a062b0b4e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (proxy/utils/UUPSUpgradeable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../interfaces/draft-IERC1822Upgradeable.sol\\\";\\nimport \\\"../ERC1967/ERC1967UpgradeUpgradeable.sol\\\";\\nimport \\\"./Initializable.sol\\\";\\n\\n/**\\n * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an\\n * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.\\n *\\n * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is\\n * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing\\n * `UUPSUpgradeable` with a custom implementation of upgrades.\\n *\\n * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.\\n *\\n * _Available since v4.1._\\n */\\nabstract contract UUPSUpgradeable is Initializable, IERC1822ProxiableUpgradeable, ERC1967UpgradeUpgradeable {\\n function __UUPSUpgradeable_init() internal onlyInitializing {\\n }\\n\\n function __UUPSUpgradeable_init_unchained() internal onlyInitializing {\\n }\\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment\\n address private immutable __self = address(this);\\n\\n /**\\n * @dev Check that the execution is being performed through a delegatecall call and that the execution context is\\n * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case\\n * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a\\n * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to\\n * fail.\\n */\\n modifier onlyProxy() {\\n require(address(this) != __self, \\\"Function must be called through delegatecall\\\");\\n require(_getImplementation() == __self, \\\"Function must be called through active proxy\\\");\\n _;\\n }\\n\\n /**\\n * @dev Check that the execution is not being performed through a delegate call. This allows a function to be\\n * callable on the implementing contract but not through proxies.\\n */\\n modifier notDelegated() {\\n require(address(this) == __self, \\\"UUPSUpgradeable: must not be called through delegatecall\\\");\\n _;\\n }\\n\\n /**\\n * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the\\n * implementation. It is used to validate that the this implementation remains valid after an upgrade.\\n *\\n * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\\n * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\\n * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.\\n */\\n function proxiableUUID() external view virtual override notDelegated returns (bytes32) {\\n return _IMPLEMENTATION_SLOT;\\n }\\n\\n /**\\n * @dev Upgrade the implementation of the proxy to `newImplementation`.\\n *\\n * Calls {_authorizeUpgrade}.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function upgradeTo(address newImplementation) external virtual onlyProxy {\\n _authorizeUpgrade(newImplementation);\\n _upgradeToAndCallUUPS(newImplementation, new bytes(0), false);\\n }\\n\\n /**\\n * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call\\n * encoded in `data`.\\n *\\n * Calls {_authorizeUpgrade}.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function upgradeToAndCall(address newImplementation, bytes memory data) external payable virtual onlyProxy {\\n _authorizeUpgrade(newImplementation);\\n _upgradeToAndCallUUPS(newImplementation, data, true);\\n }\\n\\n /**\\n * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by\\n * {upgradeTo} and {upgradeToAndCall}.\\n *\\n * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.\\n *\\n * ```solidity\\n * function _authorizeUpgrade(address) internal override onlyOwner {}\\n * ```\\n */\\n function _authorizeUpgrade(address newImplementation) internal virtual;\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x6e36e9b4b71de699c2f3f0d4e4d1aa0b35da99a26e8d5b91ef09ba234b4ef270\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x611aa3f23e59cfdd1863c536776407b3e33d695152a266fa7cfb34440a29a8a3\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StorageSlotUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for reading and writing primitive types to specific storage slots.\\n *\\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\\n * This library helps with reading and writing to such slots without the need for inline assembly.\\n *\\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\\n *\\n * Example usage to set ERC1967 implementation slot:\\n * ```\\n * contract ERC1967 {\\n * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n *\\n * function _getImplementation() internal view returns (address) {\\n * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\\n * }\\n *\\n * function _setImplementation(address newImplementation) internal {\\n * require(Address.isContract(newImplementation), \\\"ERC1967: new implementation is not a contract\\\");\\n * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\\n * }\\n * }\\n * ```\\n *\\n * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._\\n */\\nlibrary StorageSlotUpgradeable {\\n struct AddressSlot {\\n address value;\\n }\\n\\n struct BooleanSlot {\\n bool value;\\n }\\n\\n struct Bytes32Slot {\\n bytes32 value;\\n }\\n\\n struct Uint256Slot {\\n uint256 value;\\n }\\n\\n /**\\n * @dev Returns an `AddressSlot` with member `value` located at `slot`.\\n */\\n function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\\n */\\n function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\\n */\\n function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\\n */\\n function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n}\\n\",\"keccak256\":\"0x09864aea84f01e39313375b5610c73a3c1c68abbdc51e5ccdd25ff977fdadf9a\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor() {\\n _transferOwnership(_msgSender());\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n _checkOwner();\\n _;\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if the sender is not the owner.\\n */\\n function _checkOwner() internal view virtual {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n _transferOwnership(address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n _transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n address oldOwner = _owner;\\n _owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner);\\n }\\n}\\n\",\"keccak256\":\"0xa94b34880e3c1b0b931662cb1c09e5dfa6662f31cba80e07c5ee71cd135c9673\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/draft-IERC1822.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified\\n * proxy whose upgrades are fully controlled by the current implementation.\\n */\\ninterface IERC1822Proxiable {\\n /**\\n * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation\\n * address.\\n *\\n * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\\n * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\\n * function revert if invoked through a proxy.\\n */\\n function proxiableUUID() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0x1d4afe6cb24200cc4545eed814ecf5847277dfe5d613a1707aad5fceecebcfff\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (proxy/ERC1967/ERC1967Proxy.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../Proxy.sol\\\";\\nimport \\\"./ERC1967Upgrade.sol\\\";\\n\\n/**\\n * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an\\n * implementation address that can be changed. This address is stored in storage in the location specified by\\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the\\n * implementation behind the proxy.\\n */\\ncontract ERC1967Proxy is Proxy, ERC1967Upgrade {\\n /**\\n * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.\\n *\\n * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded\\n * function call, and allows initializing the storage of the proxy like a Solidity constructor.\\n */\\n constructor(address _logic, bytes memory _data) payable {\\n _upgradeToAndCall(_logic, _data, false);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function _implementation() internal view virtual override returns (address impl) {\\n return ERC1967Upgrade._getImplementation();\\n }\\n}\\n\",\"keccak256\":\"0xa2b22da3032e50b55f95ec1d13336102d675f341167aa76db571ef7f8bb7975d\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/ERC1967/ERC1967Upgrade.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../beacon/IBeacon.sol\\\";\\nimport \\\"../../interfaces/draft-IERC1822.sol\\\";\\nimport \\\"../../utils/Address.sol\\\";\\nimport \\\"../../utils/StorageSlot.sol\\\";\\n\\n/**\\n * @dev This abstract contract provides getters and event emitting update functions for\\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.\\n *\\n * _Available since v4.1._\\n *\\n * @custom:oz-upgrades-unsafe-allow delegatecall\\n */\\nabstract contract ERC1967Upgrade {\\n // This is the keccak-256 hash of \\\"eip1967.proxy.rollback\\\" subtracted by 1\\n bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;\\n\\n /**\\n * @dev Storage slot with the address of the current implementation.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.implementation\\\" subtracted by 1, and is\\n * validated in the constructor.\\n */\\n bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n /**\\n * @dev Emitted when the implementation is upgraded.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function _getImplementation() internal view returns (address) {\\n return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new address in the EIP1967 implementation slot.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(Address.isContract(newImplementation), \\\"ERC1967: new implementation is not a contract\\\");\\n StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\\n }\\n\\n /**\\n * @dev Perform implementation upgrade\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeTo(address newImplementation) internal {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Perform implementation upgrade with additional setup call.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeToAndCall(\\n address newImplementation,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n _upgradeTo(newImplementation);\\n if (data.length > 0 || forceCall) {\\n Address.functionDelegateCall(newImplementation, data);\\n }\\n }\\n\\n /**\\n * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeToAndCallUUPS(\\n address newImplementation,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n // Upgrades from old implementations will perform a rollback test. This test requires the new\\n // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing\\n // this special case will break upgrade paths from old UUPS implementation to new ones.\\n if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {\\n _setImplementation(newImplementation);\\n } else {\\n try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {\\n require(slot == _IMPLEMENTATION_SLOT, \\\"ERC1967Upgrade: unsupported proxiableUUID\\\");\\n } catch {\\n revert(\\\"ERC1967Upgrade: new implementation is not UUPS\\\");\\n }\\n _upgradeToAndCall(newImplementation, data, forceCall);\\n }\\n }\\n\\n /**\\n * @dev Storage slot with the admin of the contract.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.admin\\\" subtracted by 1, and is\\n * validated in the constructor.\\n */\\n bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\\n\\n /**\\n * @dev Emitted when the admin account has changed.\\n */\\n event AdminChanged(address previousAdmin, address newAdmin);\\n\\n /**\\n * @dev Returns the current admin.\\n */\\n function _getAdmin() internal view returns (address) {\\n return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new address in the EIP1967 admin slot.\\n */\\n function _setAdmin(address newAdmin) private {\\n require(newAdmin != address(0), \\\"ERC1967: new admin is the zero address\\\");\\n StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;\\n }\\n\\n /**\\n * @dev Changes the admin of the proxy.\\n *\\n * Emits an {AdminChanged} event.\\n */\\n function _changeAdmin(address newAdmin) internal {\\n emit AdminChanged(_getAdmin(), newAdmin);\\n _setAdmin(newAdmin);\\n }\\n\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Emitted when the beacon is upgraded.\\n */\\n event BeaconUpgraded(address indexed beacon);\\n\\n /**\\n * @dev Returns the current beacon.\\n */\\n function _getBeacon() internal view returns (address) {\\n return StorageSlot.getAddressSlot(_BEACON_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new beacon in the EIP1967 beacon slot.\\n */\\n function _setBeacon(address newBeacon) private {\\n require(Address.isContract(newBeacon), \\\"ERC1967: new beacon is not a contract\\\");\\n require(\\n Address.isContract(IBeacon(newBeacon).implementation()),\\n \\\"ERC1967: beacon implementation is not a contract\\\"\\n );\\n StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;\\n }\\n\\n /**\\n * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does\\n * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).\\n *\\n * Emits a {BeaconUpgraded} event.\\n */\\n function _upgradeBeaconToAndCall(\\n address newBeacon,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n _setBeacon(newBeacon);\\n emit BeaconUpgraded(newBeacon);\\n if (data.length > 0 || forceCall) {\\n Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xabf3f59bc0e5423eae45e459dbe92e7052c6983628d39008590edc852a62f94a\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internal call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overridden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internal call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback() external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive() external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overridden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {}\\n}\\n\",\"keccak256\":\"0xc130fe33f1b2132158531a87734153293f6d07bc263ff4ac90e85da9c82c0e27\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0xd50a3421ac379ccb1be435fa646d66a65c986b4924f0849839f08692f39dde61\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd6153ce99bcdcce22b124f755e72553295be6abcd63804cfdffceb188b8bef10\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xe2e337e6dde9ef6b680e07338c493ebea1b5fd09b43424112868e9cc1706bca7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Create2.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Create2.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Helper to make usage of the `CREATE2` EVM opcode easier and safer.\\n * `CREATE2` can be used to compute in advance the address where a smart\\n * contract will be deployed, which allows for interesting new mechanisms known\\n * as 'counterfactual interactions'.\\n *\\n * See the https://eips.ethereum.org/EIPS/eip-1014#motivation[EIP] for more\\n * information.\\n */\\nlibrary Create2 {\\n /**\\n * @dev Deploys a contract using `CREATE2`. The address where the contract\\n * will be deployed can be known in advance via {computeAddress}.\\n *\\n * The bytecode for a contract can be obtained from Solidity with\\n * `type(contractName).creationCode`.\\n *\\n * Requirements:\\n *\\n * - `bytecode` must not be empty.\\n * - `salt` must have not been used for `bytecode` already.\\n * - the factory must have a balance of at least `amount`.\\n * - if `amount` is non-zero, `bytecode` must have a `payable` constructor.\\n */\\n function deploy(\\n uint256 amount,\\n bytes32 salt,\\n bytes memory bytecode\\n ) internal returns (address) {\\n address addr;\\n require(address(this).balance >= amount, \\\"Create2: insufficient balance\\\");\\n require(bytecode.length != 0, \\\"Create2: bytecode length is zero\\\");\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt)\\n }\\n require(addr != address(0), \\\"Create2: Failed on deploy\\\");\\n return addr;\\n }\\n\\n /**\\n * @dev Returns the address where a contract will be stored if deployed via {deploy}. Any change in the\\n * `bytecodeHash` or `salt` will result in a new destination address.\\n */\\n function computeAddress(bytes32 salt, bytes32 bytecodeHash) internal view returns (address) {\\n return computeAddress(salt, bytecodeHash, address(this));\\n }\\n\\n /**\\n * @dev Returns the address where a contract will be stored if deployed via {deploy} from a contract located at\\n * `deployer`. If `deployer` is this contract's address, returns the same value as {computeAddress}.\\n */\\n function computeAddress(\\n bytes32 salt,\\n bytes32 bytecodeHash,\\n address deployer\\n ) internal pure returns (address) {\\n bytes32 _data = keccak256(abi.encodePacked(bytes1(0xff), deployer, salt, bytecodeHash));\\n return address(uint160(uint256(_data)));\\n }\\n}\\n\",\"keccak256\":\"0x62237e1773cbf99739b7019f3772a2ff5360d56edb69751b513237f5fcd78571\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/StorageSlot.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for reading and writing primitive types to specific storage slots.\\n *\\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\\n * This library helps with reading and writing to such slots without the need for inline assembly.\\n *\\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\\n *\\n * Example usage to set ERC1967 implementation slot:\\n * ```\\n * contract ERC1967 {\\n * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n *\\n * function _getImplementation() internal view returns (address) {\\n * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\\n * }\\n *\\n * function _setImplementation(address newImplementation) internal {\\n * require(Address.isContract(newImplementation), \\\"ERC1967: new implementation is not a contract\\\");\\n * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\\n * }\\n * }\\n * ```\\n *\\n * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._\\n */\\nlibrary StorageSlot {\\n struct AddressSlot {\\n address value;\\n }\\n\\n struct BooleanSlot {\\n bool value;\\n }\\n\\n struct Bytes32Slot {\\n bytes32 value;\\n }\\n\\n struct Uint256Slot {\\n uint256 value;\\n }\\n\\n /**\\n * @dev Returns an `AddressSlot` with member `value` located at `slot`.\\n */\\n function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\\n */\\n function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\\n */\\n function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\\n */\\n function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd5c50c54bf02740ebd122ff06832546cb5fa84486d52695a9ccfd11666e0c81d\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/ERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165 is IERC165 {\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165).interfaceId;\\n }\\n}\\n\",\"keccak256\":\"0xd10975de010d89fd1c78dc5e8a9a7e7f496198085c151648f20cba166b32582b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/ERC165Storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165Storage.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./ERC165.sol\\\";\\n\\n/**\\n * @dev Storage based implementation of the {IERC165} interface.\\n *\\n * Contracts may inherit from this and call {_registerInterface} to declare\\n * their support of an interface.\\n */\\nabstract contract ERC165Storage is ERC165 {\\n /**\\n * @dev Mapping of interface ids to whether or not it's supported.\\n */\\n mapping(bytes4 => bool) private _supportedInterfaces;\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return super.supportsInterface(interfaceId) || _supportedInterfaces[interfaceId];\\n }\\n\\n /**\\n * @dev Registers the contract as an implementer of the interface defined by\\n * `interfaceId`. Support of the actual ERC165 interface is automatic and\\n * registering its interface id is not required.\\n *\\n * See {IERC165-supportsInterface}.\\n *\\n * Requirements:\\n *\\n * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).\\n */\\n function _registerInterface(bytes4 interfaceId) internal virtual {\\n require(interfaceId != 0xffffffff, \\\"ERC165: invalid interface id\\\");\\n _supportedInterfaces[interfaceId] = true;\\n }\\n}\\n\",\"keccak256\":\"0x77bf0086774bab931413c3388d3a0f7d44cf6878965b72147f57bb0fbbf394bd\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x447a5f3ddc18419d41ff92b3773fb86471b1db25773e07f877f548918a185bf1\",\"license\":\"MIT\"},\"contracts/GnosisWrapper.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\npragma solidity ^0.8.0;\\n\\nimport \\\"@fractal-framework/core-contracts/contracts/ModuleBase.sol\\\";\\nimport \\\"./IGnosisWrapper.sol\\\";\\n\\ncontract GnosisWrapper is ModuleBase {\\n address public gnosisSafe;\\n\\n function initialize(address _accessControl, address _gnosisSafe)\\n public\\n initializer\\n {\\n __initBase(_accessControl, msg.sender, \\\"Wrapper Module\\\");\\n _registerInterface(type(IGnosisWrapper).interfaceId);\\n gnosisSafe = _gnosisSafe;\\n }\\n}\\n\",\"keccak256\":\"0x9170ce2706b5f2f858077655d0b49e83b438b080be113055ec4fb8a357c91e4a\",\"license\":\"Unlicense\"},\"contracts/GnosisWrapperFactory.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/Create2.sol\\\";\\nimport \\\"./GnosisWrapper.sol\\\";\\n\\nimport \\\"@fractal-framework/core-contracts/contracts/ModuleFactoryBase.sol\\\";\\n\\n/// @dev GnosisWrapper Factory used to deploy Gnosis Modules\\ncontract GnosisWrapperFactory is ModuleFactoryBase {\\n event GnosisWrapperCreated(address gnosisSafe);\\n\\n function initialize() external initializer {\\n __initFactoryBase();\\n }\\n\\n /// @dev Creates a GnosisWrapper module\\n /// @param creator The address creating the module\\n /// @param data The array of bytes used to create the module\\n /// @return address[] The array of addresses of the created module\\n function create(address creator, bytes[] calldata data)\\n external\\n override\\n returns (address[] memory)\\n {\\n address[] memory createdContracts = new address[](1);\\n\\n createdContracts[0] = createGnosisWrapper(creator, data);\\n\\n emit GnosisWrapperCreated(createdContracts[0]);\\n\\n return createdContracts;\\n }\\n\\n function createGnosisWrapper(address creator, bytes[] memory data)\\n private\\n returns (address gnosisWrapper)\\n {\\n // Create wrapper\\n gnosisWrapper = Create2.deploy(\\n 0,\\n keccak256(\\n abi.encodePacked(\\n creator,\\n msg.sender,\\n block.chainid,\\n abi.decode(data[3], (bytes32)) // random salt\\n )\\n ),\\n abi.encodePacked(\\n type(ERC1967Proxy).creationCode,\\n abi.encode(address(abi.decode(data[2], (address))), \\\"\\\") // impl address\\n )\\n );\\n\\n GnosisWrapper(gnosisWrapper).initialize(\\n abi.decode(data[0], (address)),\\n abi.decode(data[1], (address))\\n ); // access Control, gnosisSafe\\n }\\n}\\n\",\"keccak256\":\"0x003e14b6ea219714a461f6329351b856a8b49be9252da7c3207530caf0e899e6\",\"license\":\"Unlicense\"},\"contracts/IGnosisWrapper.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\npragma solidity ^0.8.0;\\n\\ninterface IGnosisWrapper {\\n function initialize(address _accessControl, address _gnosisSafe) external;\\n function gnosisSafe() external view returns(address);\\n}\\n\",\"keccak256\":\"0xbbe3a9695df8ffc67358a2663cc8c9a4bfdd89566c525191b244398588f3d9f3\",\"license\":\"Unlicense\"}},\"version\":1}", - "bytecode": "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", - "deployedBytecode": "0x60806040523480156200001157600080fd5b5060043610620000935760003560e01c80638129fc1c11620000625780638129fc1c146200010d5780638da5cb5b1462000117578063d7bef6ce1462000133578063f2fde38b146200015b57600080fd5b806301ffc9a714620000985780634d4a76f514620000c45780636d81fc7214620000dd578063715018a61462000103575b600080fd5b620000af620000a936600462000c9f565b62000172565b60405190151581526020015b60405180910390f35b620000db620000d536600462000d34565b620001b3565b005b620000f4620000ee36600462000dc1565b620002fe565b604051620000bb919062000e50565b620000db620003dd565b620000db620003f5565b6000546040516001600160a01b039091168152602001620000bb565b6200014a6200014436600462000e9f565b6200052e565b604051620000bb9392919062000f1a565b620000db6200016c36600462000f5c565b62000692565b60006301ffc9a760e01b6001600160e01b031983161480620001ad57506001600160e01b0319821660009081526001602052604090205460ff165b92915050565b620001bd6200070e565b6040805160806020601f88018190040282018101909252606081018681526002928291908990899081908501838280828437600092019190915250505090825250604080516020601f88018190048102820181019092528681529181019190879087908190840183828082843760009201829052509385525050506001600160a01b03851660209283015283546001810185559381528190208251805193946003029091019262000272928492019062000beb565b5060208281015180516200028d926001850192019062000beb565b5060409182015160029190910180546001600160a01b0319166001600160a01b03909216919091179055517f55333c8005b89ec35427ce0dee089bf2afe5d50fd45f9afd62478d8c299f999990620002ef908790879087908790879062000fa5565b60405180910390a15050505050565b60408051600180825281830190925260609160009190602080830190803683370190505090506200033b8562000335858762001035565b6200076a565b816000815181106200035157620003516200111a565b60200260200101906001600160a01b031690816001600160a01b0316815250507ff847bcab38ed0ec4df55ba414b67ce4fb25d80d8767602894f274f4d42684a3581600081518110620003a857620003a86200111a565b6020026020010151604051620003cd91906001600160a01b0391909116815260200190565b60405180910390a1949350505050565b620003e76200070e565b620003f3600062000983565b565b600054600160a81b900460ff16158080156200041e57506000546001600160a01b90910460ff16105b80620004415750303b158015620004415750600054600160a01b900460ff166001145b620004aa5760405162461bcd60e51b815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201526d191e481a5b9a5d1a585b1a5e995960921b60648201526084015b60405180910390fd5b6000805460ff60a01b1916600160a01b1790558015620004d8576000805460ff60a81b1916600160a81b1790555b620004e2620009d3565b80156200052b576000805460ff60a81b19169055604051600181527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a15b50565b600281815481106200053f57600080fd5b9060005260206000209060030201600091509050806000018054620005649062001130565b80601f0160208091040260200160405190810160405280929190818152602001828054620005929062001130565b8015620005e35780601f10620005b757610100808354040283529160200191620005e3565b820191906000526020600020905b815481529060010190602001808311620005c557829003601f168201915b505050505090806001018054620005fa9062001130565b80601f0160208091040260200160405190810160405280929190818152602001828054620006289062001130565b8015620006795780601f106200064d5761010080835404028352916020019162000679565b820191906000526020600020905b8154815290600101906020018083116200065b57829003601f168201915b505050600290930154919250506001600160a01b031683565b6200069c6200070e565b6001600160a01b038116620007035760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b6064820152608401620004a1565b6200052b8162000983565b6000546001600160a01b03163314620003f35760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152606401620004a1565b6000620008a46000843346866003815181106200078b576200078b6200111a565b6020026020010151806020019051810190620007a891906200116c565b6040516bffffffffffffffffffffffff19606095861b811660208301529390941b9092166034840152604883015260688201526088016040516020818303038152906040528051906020012060405180602001620008069062000c7a565b6020820181038252601f19601f82011660405250856002815181106200083057620008306200111a565b60200260200101518060200190518101906200084d919062001186565b604080516001600160a01b039092166020830152818101526000606082015260800160408051601f19818403018152908290526200088f9291602001620011a6565b60405160208183030381529060405262000a54565b9050806001600160a01b031663485cc95583600081518110620008cb57620008cb6200111a565b6020026020010151806020019051810190620008e8919062001186565b84600181518110620008fe57620008fe6200111a565b60200260200101518060200190518101906200091b919062001186565b6040516001600160e01b031960e085901b1681526001600160a01b03928316600482015291166024820152604401600060405180830381600087803b1580156200096457600080fd5b505af115801562000979573d6000803e3d6000fd5b5050505092915050565b600080546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b600054600160a81b900460ff1662000a425760405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201526a6e697469616c697a696e6760a81b6064820152608401620004a1565b620003f36320cb8a8760e01b62000b67565b6000808447101562000aa95760405162461bcd60e51b815260206004820152601d60248201527f437265617465323a20696e73756666696369656e742062616c616e63650000006044820152606401620004a1565b825160000362000afc5760405162461bcd60e51b815260206004820181905260248201527f437265617465323a2062797465636f6465206c656e677468206973207a65726f6044820152606401620004a1565b8383516020850187f590506001600160a01b03811662000b5f5760405162461bcd60e51b815260206004820152601960248201527f437265617465323a204661696c6564206f6e206465706c6f79000000000000006044820152606401620004a1565b949350505050565b6001600160e01b0319808216900362000bc35760405162461bcd60e51b815260206004820152601c60248201527f4552433136353a20696e76616c696420696e74657266616365206964000000006044820152606401620004a1565b6001600160e01b0319166000908152600160208190526040909120805460ff19169091179055565b82805462000bf99062001130565b90600052602060002090601f01602090048101928262000c1d576000855562000c68565b82601f1062000c3857805160ff191683800117855562000c68565b8280016001018555821562000c68579182015b8281111562000c6857825182559160200191906001019062000c4b565b5062000c7692915062000c88565b5090565b61072180620011da83390190565b5b8082111562000c76576000815560010162000c89565b60006020828403121562000cb257600080fd5b81356001600160e01b03198116811462000ccb57600080fd5b9392505050565b60008083601f84011262000ce557600080fd5b50813567ffffffffffffffff81111562000cfe57600080fd5b60208301915083602082850101111562000d1757600080fd5b9250929050565b6001600160a01b03811681146200052b57600080fd5b60008060008060006060868803121562000d4d57600080fd5b853567ffffffffffffffff8082111562000d6657600080fd5b62000d7489838a0162000cd2565b9097509550602088013591508082111562000d8e57600080fd5b5062000d9d8882890162000cd2565b909450925050604086013562000db38162000d1e565b809150509295509295909350565b60008060006040848603121562000dd757600080fd5b833562000de48162000d1e565b9250602084013567ffffffffffffffff8082111562000e0257600080fd5b818601915086601f83011262000e1757600080fd5b81358181111562000e2757600080fd5b8760208260051b850101111562000e3d57600080fd5b6020830194508093505050509250925092565b6020808252825182820181905260009190848201906040850190845b8181101562000e935783516001600160a01b03168352928401929184019160010162000e6c565b50909695505050505050565b60006020828403121562000eb257600080fd5b5035919050565b60005b8381101562000ed657818101518382015260200162000ebc565b8381111562000ee6576000848401525b50505050565b6000815180845262000f0681602086016020860162000eb9565b601f01601f19169290920160200192915050565b60608152600062000f2f606083018662000eec565b828103602084015262000f43818662000eec565b91505060018060a01b0383166040830152949350505050565b60006020828403121562000f6f57600080fd5b813562000ccb8162000d1e565b81835281816020850137506000828201602090810191909152601f909101601f19169091010190565b60608152600062000fbb60608301878962000f7c565b828103602084015262000fd081868862000f7c565b91505060018060a01b03831660408301529695505050505050565b634e487b7160e01b600052604160045260246000fd5b604051601f8201601f1916810167ffffffffffffffff811182821017156200102d576200102d62000feb565b604052919050565b600067ffffffffffffffff8084111562001053576200105362000feb565b8360051b60206200106681830162001001565b8681529185019181810190368411156200107f57600080fd5b865b848110156200110e578035868111156200109b5760008081fd5b8801601f3681830112620010af5760008081fd5b813588811115620010c457620010c462000feb565b620010d7818301601f1916880162001001565b91508082523687828501011115620010ef5760008081fd5b8087840188840137600090820187015284525091830191830162001081565b50979650505050505050565b634e487b7160e01b600052603260045260246000fd5b600181811c908216806200114557607f821691505b6020821081036200116657634e487b7160e01b600052602260045260246000fd5b50919050565b6000602082840312156200117f57600080fd5b5051919050565b6000602082840312156200119957600080fd5b815162000ccb8162000d1e565b60008351620011ba81846020880162000eb9565b835190830190620011d081836020880162000eb9565b0194935050505056fe608060405260405161072138038061072183398101604081905261002291610314565b61002e82826000610035565b5050610431565b61003e8361006b565b60008251118061004b5750805b156100665761006483836100ab60201b6100291760201c565b505b505050565b610074816100d7565b6040516001600160a01b038216907fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b90600090a250565b60606100d083836040518060600160405280602781526020016106fa602791396101a9565b9392505050565b6100ea8161028760201b6100551760201c565b6101515760405162461bcd60e51b815260206004820152602d60248201527f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60448201526c1bdd08184818dbdb9d1c9858dd609a1b60648201526084015b60405180910390fd5b806101887f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b61029660201b6100641760201c565b80546001600160a01b0319166001600160a01b039290921691909117905550565b60606001600160a01b0384163b6102115760405162461bcd60e51b815260206004820152602660248201527f416464726573733a2064656c65676174652063616c6c20746f206e6f6e2d636f6044820152651b9d1c9858dd60d21b6064820152608401610148565b600080856001600160a01b03168560405161022c91906103e2565b600060405180830381855af49150503d8060008114610267576040519150601f19603f3d011682016040523d82523d6000602084013e61026c565b606091505b50909250905061027d828286610299565b9695505050505050565b6001600160a01b03163b151590565b90565b606083156102a85750816100d0565b8251156102b85782518084602001fd5b8160405162461bcd60e51b815260040161014891906103fe565b634e487b7160e01b600052604160045260246000fd5b60005b838110156103035781810151838201526020016102eb565b838111156100645750506000910152565b6000806040838503121561032757600080fd5b82516001600160a01b038116811461033e57600080fd5b60208401519092506001600160401b038082111561035b57600080fd5b818501915085601f83011261036f57600080fd5b815181811115610381576103816102d2565b604051601f8201601f19908116603f011681019083821181831017156103a9576103a96102d2565b816040528281528860208487010111156103c257600080fd5b6103d38360208301602088016102e8565b80955050505050509250929050565b600082516103f48184602087016102e8565b9190910192915050565b602081526000825180602084015261041d8160408501602087016102e8565b601f01601f19169190910160400192915050565b6102ba806104406000396000f3fe60806040523661001357610011610017565b005b6100115b610027610022610067565b61009f565b565b606061004e838360405180606001604052806027815260200161025e602791396100c3565b9392505050565b6001600160a01b03163b151590565b90565b600061009a7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc546001600160a01b031690565b905090565b3660008037600080366000845af43d6000803e8080156100be573d6000f35b3d6000fd5b60606001600160a01b0384163b6101305760405162461bcd60e51b815260206004820152602660248201527f416464726573733a2064656c65676174652063616c6c20746f206e6f6e2d636f6044820152651b9d1c9858dd60d21b60648201526084015b60405180910390fd5b600080856001600160a01b03168560405161014b919061020e565b600060405180830381855af49150503d8060008114610186576040519150601f19603f3d011682016040523d82523d6000602084013e61018b565b606091505b509150915061019b8282866101a5565b9695505050505050565b606083156101b457508161004e565b8251156101c45782518084602001fd5b8160405162461bcd60e51b8152600401610127919061022a565b60005b838110156101f95781810151838201526020016101e1565b83811115610208576000848401525b50505050565b600082516102208184602087016101de565b9190910192915050565b60208152600082518060208401526102498160408501602087016101de565b601f01601f1916919091016040019291505056fe416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a2646970667358221220624d8c621d429fd8b7eed49ae71e0c11f4101ae7335c4c9d149cb44a1625749c64736f6c634300080d0033416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a26469706673582212208ad626753baa2eb6af194759fa2e6795c029f47787c1513fcb965417f363229364736f6c634300080d0033", - "devdoc": { - "details": "GnosisWrapper Factory used to deploy Gnosis Modules", - "kind": "dev", - "methods": { - "addVersion(string,string,address)": { - "details": "add a new version to update module users", - "params": { - "_frontendURI": "IPFS hash of the static frontend", - "_impl": "address of the impl", - "_semanticVersion": "semantic version control" - } - }, - "create(address,bytes[])": { - "details": "Creates a GnosisWrapper module", - "params": { - "creator": "The address creating the module", - "data": "The array of bytes used to create the module" - }, - "returns": { - "_0": "address[] The array of addresses of the created module" - } - }, - "owner()": { - "details": "Returns the address of the current owner." - }, - "renounceOwnership()": { - "details": "Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner." - }, - "supportsInterface(bytes4)": { - "details": "See {IERC165-supportsInterface}." - }, - "transferOwnership(address)": { - "details": "Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner." - } - }, - "version": 1 - }, - "userdoc": { - "kind": "user", - "methods": {}, - "version": 1 - }, - "storageLayout": { - "storage": [ - { - "astId": 3018, - "contract": "contracts/GnosisWrapperFactory.sol:GnosisWrapperFactory", - "label": "_owner", - "offset": 0, - "slot": "0", - "type": "t_address" - }, - { - "astId": 2427, - "contract": "contracts/GnosisWrapperFactory.sol:GnosisWrapperFactory", - "label": "_initialized", - "offset": 20, - "slot": "0", - "type": "t_uint8" - }, - { - "astId": 2430, - "contract": "contracts/GnosisWrapperFactory.sol:GnosisWrapperFactory", - "label": "_initializing", - "offset": 21, - "slot": "0", - "type": "t_bool" - }, - { - "astId": 4073, - "contract": "contracts/GnosisWrapperFactory.sol:GnosisWrapperFactory", - "label": "_supportedInterfaces", - "offset": 0, - "slot": "1", - "type": "t_mapping(t_bytes4,t_bool)" - }, - { - "astId": 1513, - "contract": "contracts/GnosisWrapperFactory.sol:GnosisWrapperFactory", - "label": "versionControl", - "offset": 0, - "slot": "2", - "type": "t_array(t_struct(VersionInfo)1930_storage)dyn_storage" - } - ], - "types": { - "t_address": { - "encoding": "inplace", - "label": "address", - "numberOfBytes": "20" - }, - "t_array(t_struct(VersionInfo)1930_storage)dyn_storage": { - "base": "t_struct(VersionInfo)1930_storage", - "encoding": "dynamic_array", - "label": "struct IModuleFactoryBase.VersionInfo[]", - "numberOfBytes": "32" - }, - "t_bool": { - "encoding": "inplace", - "label": "bool", - "numberOfBytes": "1" - }, - "t_bytes4": { - "encoding": "inplace", - "label": "bytes4", - "numberOfBytes": "4" - }, - "t_mapping(t_bytes4,t_bool)": { - "encoding": "mapping", - "key": "t_bytes4", - "label": "mapping(bytes4 => bool)", - "numberOfBytes": "32", - "value": "t_bool" - }, - "t_string_storage": { - "encoding": "bytes", - "label": "string", - "numberOfBytes": "32" - }, - "t_struct(VersionInfo)1930_storage": { - "encoding": "inplace", - "label": "struct IModuleFactoryBase.VersionInfo", - "members": [ - { - "astId": 1925, - "contract": "contracts/GnosisWrapperFactory.sol:GnosisWrapperFactory", - "label": "semanticVersion", - "offset": 0, - "slot": "0", - "type": "t_string_storage" - }, - { - "astId": 1927, - "contract": "contracts/GnosisWrapperFactory.sol:GnosisWrapperFactory", - "label": "frontendURI", - "offset": 0, - "slot": "1", - "type": "t_string_storage" - }, - { - "astId": 1929, - "contract": "contracts/GnosisWrapperFactory.sol:GnosisWrapperFactory", - "label": "impl", - "offset": 0, - "slot": "2", - "type": "t_address" - } - ], - "numberOfBytes": "96" - }, - "t_uint8": { - "encoding": "inplace", - "label": "uint8", - "numberOfBytes": "1" - } - } - } -} \ No newline at end of file diff --git a/deployments/rinkeby/solcInputs/6e6f9d675593c08f2cd8ae1cedebec27.json b/deployments/rinkeby/solcInputs/6e6f9d675593c08f2cd8ae1cedebec27.json deleted file mode 100644 index 25eb3f20..00000000 --- a/deployments/rinkeby/solcInputs/6e6f9d675593c08f2cd8ae1cedebec27.json +++ /dev/null @@ -1,149 +0,0 @@ -{ - "language": "Solidity", - "sources": { - "contracts/GnosisWrapper.sol": { - "content": "//SPDX-License-Identifier: Unlicense\npragma solidity ^0.8.0;\n\nimport \"@fractal-framework/core-contracts/contracts/ModuleBase.sol\";\nimport \"./IGnosisWrapper.sol\";\n\ncontract GnosisWrapper is ModuleBase {\n address public gnosisSafe;\n\n function initialize(address _accessControl, address _gnosisSafe)\n public\n initializer\n {\n __initBase(_accessControl, msg.sender, \"Wrapper Module\");\n _registerInterface(type(IGnosisWrapper).interfaceId);\n gnosisSafe = _gnosisSafe;\n }\n}\n" - }, - "@fractal-framework/core-contracts/contracts/ModuleBase.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\nimport \"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\";\r\nimport \"@openzeppelin/contracts/utils/introspection/ERC165Storage.sol\";\r\nimport \"./interfaces/IModuleBase.sol\";\r\n\r\n/// @notice An abstract contract to be inherited by module contracts\r\nabstract contract ModuleBase is IModuleBase, UUPSUpgradeable, ERC165Storage {\r\n IDAOAccessControl public accessControl;\r\n address public moduleFactory;\r\n string internal _name;\r\n\r\n /// @notice Requires that a function caller has the associated role\r\n modifier authorized() {\r\n if (\r\n !accessControl.actionIsAuthorized(\r\n msg.sender,\r\n address(this),\r\n msg.sig\r\n )\r\n ) {\r\n revert NotAuthorized();\r\n }\r\n _;\r\n }\r\n\r\n /// @notice Function for initializing the contract that can only be called once\r\n /// @param _accessControl The address of the access control contract\r\n /// @param _moduleFactory The address of the factory deploying the module\r\n /// @param __name Human readable string of the module name\r\n function __initBase(address _accessControl, address _moduleFactory, string memory __name)\r\n internal\r\n onlyInitializing\r\n {\r\n accessControl = IDAOAccessControl(_accessControl);\r\n moduleFactory = _moduleFactory;\r\n _name = __name;\r\n __UUPSUpgradeable_init();\r\n _registerInterface(type(IModuleBase).interfaceId);\r\n }\r\n\r\n /// @dev Applies authorized modifier so that an upgrade require the caller to have the correct role\r\n /// @param newImplementation The address of the new implementation contract being upgraded to\r\n function _authorizeUpgrade(address newImplementation)\r\n internal\r\n override\r\n authorized\r\n {}\r\n\r\n /// @notice Returns the module name\r\n /// @return The module name\r\n function name() public view virtual returns (string memory) {\r\n return _name;\r\n }\r\n}\r\n" - }, - "contracts/IGnosisWrapper.sol": { - "content": "//SPDX-License-Identifier: Unlicense\npragma solidity ^0.8.0;\n\ninterface IGnosisWrapper {\n function initialize(address _accessControl, address _gnosisSafe) external;\n function gnosisSafe() external view returns(address);\n}\n" - }, - "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (proxy/utils/UUPSUpgradeable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../../interfaces/draft-IERC1822Upgradeable.sol\";\nimport \"../ERC1967/ERC1967UpgradeUpgradeable.sol\";\nimport \"./Initializable.sol\";\n\n/**\n * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an\n * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.\n *\n * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is\n * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing\n * `UUPSUpgradeable` with a custom implementation of upgrades.\n *\n * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.\n *\n * _Available since v4.1._\n */\nabstract contract UUPSUpgradeable is Initializable, IERC1822ProxiableUpgradeable, ERC1967UpgradeUpgradeable {\n function __UUPSUpgradeable_init() internal onlyInitializing {\n }\n\n function __UUPSUpgradeable_init_unchained() internal onlyInitializing {\n }\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment\n address private immutable __self = address(this);\n\n /**\n * @dev Check that the execution is being performed through a delegatecall call and that the execution context is\n * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case\n * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a\n * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to\n * fail.\n */\n modifier onlyProxy() {\n require(address(this) != __self, \"Function must be called through delegatecall\");\n require(_getImplementation() == __self, \"Function must be called through active proxy\");\n _;\n }\n\n /**\n * @dev Check that the execution is not being performed through a delegate call. This allows a function to be\n * callable on the implementing contract but not through proxies.\n */\n modifier notDelegated() {\n require(address(this) == __self, \"UUPSUpgradeable: must not be called through delegatecall\");\n _;\n }\n\n /**\n * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the\n * implementation. It is used to validate that the this implementation remains valid after an upgrade.\n *\n * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\n * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\n * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.\n */\n function proxiableUUID() external view virtual override notDelegated returns (bytes32) {\n return _IMPLEMENTATION_SLOT;\n }\n\n /**\n * @dev Upgrade the implementation of the proxy to `newImplementation`.\n *\n * Calls {_authorizeUpgrade}.\n *\n * Emits an {Upgraded} event.\n */\n function upgradeTo(address newImplementation) external virtual onlyProxy {\n _authorizeUpgrade(newImplementation);\n _upgradeToAndCallUUPS(newImplementation, new bytes(0), false);\n }\n\n /**\n * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call\n * encoded in `data`.\n *\n * Calls {_authorizeUpgrade}.\n *\n * Emits an {Upgraded} event.\n */\n function upgradeToAndCall(address newImplementation, bytes memory data) external payable virtual onlyProxy {\n _authorizeUpgrade(newImplementation);\n _upgradeToAndCallUUPS(newImplementation, data, true);\n }\n\n /**\n * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by\n * {upgradeTo} and {upgradeToAndCall}.\n *\n * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.\n *\n * ```solidity\n * function _authorizeUpgrade(address) internal override onlyOwner {}\n * ```\n */\n function _authorizeUpgrade(address newImplementation) internal virtual;\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[50] private __gap;\n}\n" - }, - "@openzeppelin/contracts/utils/introspection/ERC165Storage.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165Storage.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./ERC165.sol\";\n\n/**\n * @dev Storage based implementation of the {IERC165} interface.\n *\n * Contracts may inherit from this and call {_registerInterface} to declare\n * their support of an interface.\n */\nabstract contract ERC165Storage is ERC165 {\n /**\n * @dev Mapping of interface ids to whether or not it's supported.\n */\n mapping(bytes4 => bool) private _supportedInterfaces;\n\n /**\n * @dev See {IERC165-supportsInterface}.\n */\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n return super.supportsInterface(interfaceId) || _supportedInterfaces[interfaceId];\n }\n\n /**\n * @dev Registers the contract as an implementer of the interface defined by\n * `interfaceId`. Support of the actual ERC165 interface is automatic and\n * registering its interface id is not required.\n *\n * See {IERC165-supportsInterface}.\n *\n * Requirements:\n *\n * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).\n */\n function _registerInterface(bytes4 interfaceId) internal virtual {\n require(interfaceId != 0xffffffff, \"ERC165: invalid interface id\");\n _supportedInterfaces[interfaceId] = true;\n }\n}\n" - }, - "@fractal-framework/core-contracts/contracts/interfaces/IModuleBase.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\nimport \"./IDAOAccessControl.sol\";\r\n\r\ninterface IModuleBase {\r\n error NotAuthorized();\r\n\r\n /// @return IDAOAccessControl The Access control interface\r\n function accessControl() external view returns (IDAOAccessControl);\r\n\r\n /// @return string The string \"Name\"\r\n function name() external view returns (string memory);\r\n}\r\n" - }, - "@openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified\n * proxy whose upgrades are fully controlled by the current implementation.\n */\ninterface IERC1822ProxiableUpgradeable {\n /**\n * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation\n * address.\n *\n * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\n * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\n * function revert if invoked through a proxy.\n */\n function proxiableUUID() external view returns (bytes32);\n}\n" - }, - "@openzeppelin/contracts-upgradeable/proxy/ERC1967/ERC1967UpgradeUpgradeable.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../beacon/IBeaconUpgradeable.sol\";\nimport \"../../interfaces/draft-IERC1822Upgradeable.sol\";\nimport \"../../utils/AddressUpgradeable.sol\";\nimport \"../../utils/StorageSlotUpgradeable.sol\";\nimport \"../utils/Initializable.sol\";\n\n/**\n * @dev This abstract contract provides getters and event emitting update functions for\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.\n *\n * _Available since v4.1._\n *\n * @custom:oz-upgrades-unsafe-allow delegatecall\n */\nabstract contract ERC1967UpgradeUpgradeable is Initializable {\n function __ERC1967Upgrade_init() internal onlyInitializing {\n }\n\n function __ERC1967Upgrade_init_unchained() internal onlyInitializing {\n }\n // This is the keccak-256 hash of \"eip1967.proxy.rollback\" subtracted by 1\n bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;\n\n /**\n * @dev Storage slot with the address of the current implementation.\n * This is the keccak-256 hash of \"eip1967.proxy.implementation\" subtracted by 1, and is\n * validated in the constructor.\n */\n bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n /**\n * @dev Emitted when the implementation is upgraded.\n */\n event Upgraded(address indexed implementation);\n\n /**\n * @dev Returns the current implementation address.\n */\n function _getImplementation() internal view returns (address) {\n return StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n }\n\n /**\n * @dev Stores a new address in the EIP1967 implementation slot.\n */\n function _setImplementation(address newImplementation) private {\n require(AddressUpgradeable.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n }\n\n /**\n * @dev Perform implementation upgrade\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeTo(address newImplementation) internal {\n _setImplementation(newImplementation);\n emit Upgraded(newImplementation);\n }\n\n /**\n * @dev Perform implementation upgrade with additional setup call.\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeToAndCall(\n address newImplementation,\n bytes memory data,\n bool forceCall\n ) internal {\n _upgradeTo(newImplementation);\n if (data.length > 0 || forceCall) {\n _functionDelegateCall(newImplementation, data);\n }\n }\n\n /**\n * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeToAndCallUUPS(\n address newImplementation,\n bytes memory data,\n bool forceCall\n ) internal {\n // Upgrades from old implementations will perform a rollback test. This test requires the new\n // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing\n // this special case will break upgrade paths from old UUPS implementation to new ones.\n if (StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT).value) {\n _setImplementation(newImplementation);\n } else {\n try IERC1822ProxiableUpgradeable(newImplementation).proxiableUUID() returns (bytes32 slot) {\n require(slot == _IMPLEMENTATION_SLOT, \"ERC1967Upgrade: unsupported proxiableUUID\");\n } catch {\n revert(\"ERC1967Upgrade: new implementation is not UUPS\");\n }\n _upgradeToAndCall(newImplementation, data, forceCall);\n }\n }\n\n /**\n * @dev Storage slot with the admin of the contract.\n * This is the keccak-256 hash of \"eip1967.proxy.admin\" subtracted by 1, and is\n * validated in the constructor.\n */\n bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\n\n /**\n * @dev Emitted when the admin account has changed.\n */\n event AdminChanged(address previousAdmin, address newAdmin);\n\n /**\n * @dev Returns the current admin.\n */\n function _getAdmin() internal view returns (address) {\n return StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value;\n }\n\n /**\n * @dev Stores a new address in the EIP1967 admin slot.\n */\n function _setAdmin(address newAdmin) private {\n require(newAdmin != address(0), \"ERC1967: new admin is the zero address\");\n StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value = newAdmin;\n }\n\n /**\n * @dev Changes the admin of the proxy.\n *\n * Emits an {AdminChanged} event.\n */\n function _changeAdmin(address newAdmin) internal {\n emit AdminChanged(_getAdmin(), newAdmin);\n _setAdmin(newAdmin);\n }\n\n /**\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\n */\n bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\n\n /**\n * @dev Emitted when the beacon is upgraded.\n */\n event BeaconUpgraded(address indexed beacon);\n\n /**\n * @dev Returns the current beacon.\n */\n function _getBeacon() internal view returns (address) {\n return StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value;\n }\n\n /**\n * @dev Stores a new beacon in the EIP1967 beacon slot.\n */\n function _setBeacon(address newBeacon) private {\n require(AddressUpgradeable.isContract(newBeacon), \"ERC1967: new beacon is not a contract\");\n require(\n AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()),\n \"ERC1967: beacon implementation is not a contract\"\n );\n StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value = newBeacon;\n }\n\n /**\n * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does\n * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).\n *\n * Emits a {BeaconUpgraded} event.\n */\n function _upgradeBeaconToAndCall(\n address newBeacon,\n bytes memory data,\n bool forceCall\n ) internal {\n _setBeacon(newBeacon);\n emit BeaconUpgraded(newBeacon);\n if (data.length > 0 || forceCall) {\n _functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data);\n }\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function _functionDelegateCall(address target, bytes memory data) private returns (bytes memory) {\n require(AddressUpgradeable.isContract(target), \"Address: delegate call to non-contract\");\n\n // solhint-disable-next-line avoid-low-level-calls\n (bool success, bytes memory returndata) = target.delegatecall(data);\n return AddressUpgradeable.verifyCallResult(success, returndata, \"Address: low-level delegate call failed\");\n }\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[50] private __gap;\n}\n" - }, - "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../../utils/AddressUpgradeable.sol\";\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\n * reused. This mechanism prevents re-execution of each \"step\" but allows the creation of new initialization steps in\n * case an upgrade adds a module that needs to be initialized.\n *\n * For example:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * contract MyToken is ERC20Upgradeable {\n * function initialize() initializer public {\n * __ERC20_init(\"MyToken\", \"MTK\");\n * }\n * }\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\n * function initializeV2() reinitializer(2) public {\n * __ERC20Permit_init(\"MyToken\");\n * }\n * }\n * ```\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n *\n * [CAUTION]\n * ====\n * Avoid leaving a contract uninitialized.\n *\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * /// @custom:oz-upgrades-unsafe-allow constructor\n * constructor() {\n * _disableInitializers();\n * }\n * ```\n * ====\n */\nabstract contract Initializable {\n /**\n * @dev Indicates that the contract has been initialized.\n * @custom:oz-retyped-from bool\n */\n uint8 private _initialized;\n\n /**\n * @dev Indicates that the contract is in the process of being initialized.\n */\n bool private _initializing;\n\n /**\n * @dev Triggered when the contract has been initialized or reinitialized.\n */\n event Initialized(uint8 version);\n\n /**\n * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\n * `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`.\n */\n modifier initializer() {\n bool isTopLevelCall = !_initializing;\n require(\n (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\n \"Initializable: contract is already initialized\"\n );\n _initialized = 1;\n if (isTopLevelCall) {\n _initializing = true;\n }\n _;\n if (isTopLevelCall) {\n _initializing = false;\n emit Initialized(1);\n }\n }\n\n /**\n * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\n * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\n * used to initialize parent contracts.\n *\n * `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original\n * initialization step. This is essential to configure modules that are added through upgrades and that require\n * initialization.\n *\n * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\n * a contract, executing them in the right order is up to the developer or operator.\n */\n modifier reinitializer(uint8 version) {\n require(!_initializing && _initialized < version, \"Initializable: contract is already initialized\");\n _initialized = version;\n _initializing = true;\n _;\n _initializing = false;\n emit Initialized(version);\n }\n\n /**\n * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\n * {initializer} and {reinitializer} modifiers, directly or indirectly.\n */\n modifier onlyInitializing() {\n require(_initializing, \"Initializable: contract is not initializing\");\n _;\n }\n\n /**\n * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\n * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\n * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\n * through proxies.\n */\n function _disableInitializers() internal virtual {\n require(!_initializing, \"Initializable: contract is initializing\");\n if (_initialized < type(uint8).max) {\n _initialized = type(uint8).max;\n emit Initialized(type(uint8).max);\n }\n }\n}\n" - }, - "@openzeppelin/contracts-upgradeable/proxy/beacon/IBeaconUpgradeable.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\n */\ninterface IBeaconUpgradeable {\n /**\n * @dev Must return an address that can be used as a delegate call target.\n *\n * {BeaconProxy} will check that this address is a contract.\n */\n function implementation() external view returns (address);\n}\n" - }, - "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary AddressUpgradeable {\n /**\n * @dev Returns true if `account` is a contract.\n *\n * [IMPORTANT]\n * ====\n * It is unsafe to assume that an address for which this function returns\n * false is an externally-owned account (EOA) and not a contract.\n *\n * Among others, `isContract` will return false for the following\n * types of addresses:\n *\n * - an externally-owned account\n * - a contract in construction\n * - an address where a contract will be created\n * - an address where a contract lived, but was destroyed\n * ====\n *\n * [IMPORTANT]\n * ====\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\n *\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n * constructor.\n * ====\n */\n function isContract(address account) internal view returns (bool) {\n // This method relies on extcodesize/address.code.length, which returns 0\n // for contracts in construction, since the code is only stored at the end\n // of the constructor execution.\n\n return account.code.length > 0;\n }\n\n /**\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n * `recipient`, forwarding all available gas and reverting on errors.\n *\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\n * imposed by `transfer`, making them unable to receive funds via\n * `transfer`. {sendValue} removes this limitation.\n *\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n *\n * IMPORTANT: because control is transferred to `recipient`, care must be\n * taken to not create reentrancy vulnerabilities. Consider using\n * {ReentrancyGuard} or the\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n */\n function sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n (bool success, ) = recipient.call{value: amount}(\"\");\n require(success, \"Address: unable to send value, recipient may have reverted\");\n }\n\n /**\n * @dev Performs a Solidity function call using a low level `call`. A\n * plain `call` is an unsafe replacement for a function call: use this\n * function instead.\n *\n * If `target` reverts with a revert reason, it is bubbled up by this\n * function (like regular Solidity function calls).\n *\n * Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n *\n * Requirements:\n *\n * - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCall(target, data, \"Address: low-level call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n * `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n *\n * Requirements:\n *\n * - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n * with `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value,\n string memory errorMessage\n ) internal returns (bytes memory) {\n require(address(this).balance >= value, \"Address: insufficient balance for call\");\n require(isContract(target), \"Address: call to non-contract\");\n\n (bool success, bytes memory returndata) = target.call{value: value}(data);\n return verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, \"Address: low-level static call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal view returns (bytes memory) {\n require(isContract(target), \"Address: static call to non-contract\");\n\n (bool success, bytes memory returndata) = target.staticcall(data);\n return verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\n * revert reason using the provided one.\n *\n * _Available since v4.3._\n */\n function verifyCallResult(\n bool success,\n bytes memory returndata,\n string memory errorMessage\n ) internal pure returns (bytes memory) {\n if (success) {\n return returndata;\n } else {\n // Look for revert reason and bubble it up if present\n if (returndata.length > 0) {\n // The easiest way to bubble the revert reason is using memory via assembly\n /// @solidity memory-safe-assembly\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(errorMessage);\n }\n }\n }\n}\n" - }, - "@openzeppelin/contracts-upgradeable/utils/StorageSlotUpgradeable.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Library for reading and writing primitive types to specific storage slots.\n *\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\n * This library helps with reading and writing to such slots without the need for inline assembly.\n *\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\n *\n * Example usage to set ERC1967 implementation slot:\n * ```\n * contract ERC1967 {\n * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n *\n * function _getImplementation() internal view returns (address) {\n * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n * }\n *\n * function _setImplementation(address newImplementation) internal {\n * require(Address.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n * }\n * }\n * ```\n *\n * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._\n */\nlibrary StorageSlotUpgradeable {\n struct AddressSlot {\n address value;\n }\n\n struct BooleanSlot {\n bool value;\n }\n\n struct Bytes32Slot {\n bytes32 value;\n }\n\n struct Uint256Slot {\n uint256 value;\n }\n\n /**\n * @dev Returns an `AddressSlot` with member `value` located at `slot`.\n */\n function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\n */\n function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\n */\n function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\n */\n function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n }\n}\n" - }, - "@openzeppelin/contracts/utils/introspection/ERC165.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC165.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n *\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\n */\nabstract contract ERC165 is IERC165 {\n /**\n * @dev See {IERC165-supportsInterface}.\n */\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n return interfaceId == type(IERC165).interfaceId;\n }\n}\n" - }, - "@openzeppelin/contracts/utils/introspection/IERC165.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n /**\n * @dev Returns true if this contract implements the interface defined by\n * `interfaceId`. See the corresponding\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\n * to learn more about how these ids are created.\n *\n * This function call must use less than 30 000 gas.\n */\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n" - }, - "@fractal-framework/core-contracts/contracts/interfaces/IDAOAccessControl.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\ninterface IDAOAccessControl {\r\n struct RoleData {\r\n mapping(address => bool) members;\r\n string adminRole;\r\n }\r\n\r\n error UnequalArrayLengths();\r\n error MissingRole(address account, string role);\r\n error OnlySelfRenounce();\r\n\r\n event ActionRoleAdded(\r\n address target,\r\n string functionDesc,\r\n bytes4 encodedSig,\r\n string role\r\n );\r\n event ActionRoleRemoved(\r\n address target,\r\n string functionDesc,\r\n bytes4 encodedSig,\r\n string role\r\n );\r\n event RoleAdminChanged(\r\n string role,\r\n string previousAdminRole,\r\n string adminRole\r\n );\r\n event RoleGranted(string role, address account, address admin);\r\n event RoleRevoked(string role, address account, address admin);\r\n\r\n /// @notice Initialize DAO action and role permissions\r\n /// @param dao Address to receive DAO role\r\n /// @param roles What permissions are assigned to\r\n /// @param roleAdmins Roles which have the ability to remove or add members\r\n /// @param members Addresses to be granted the specified roles\r\n /// @param targets Contract addresses for actions to be defined on\r\n /// @param functionDescs Function descriptions used to define actions\r\n /// @param actionRoles Roles being granted permission for an action\r\n function initialize(\r\n address dao,\r\n string[] memory roles,\r\n string[] memory roleAdmins,\r\n address[][] memory members,\r\n address[] memory targets,\r\n string[] memory functionDescs,\r\n string[][] memory actionRoles\r\n ) external;\r\n\r\n /// @notice Grants roles to the specified addresses and defines admin roles\r\n /// @notice This function can only be called by the DAO\r\n /// @param roles The roles being granted\r\n /// @param roleAdmins The roles being granted as admins of the specified of roles\r\n /// @param members Addresses being granted each specified role\r\n function daoGrantRolesAndAdmins(\r\n string[] memory roles,\r\n string[] memory roleAdmins,\r\n address[][] memory members\r\n ) external;\r\n\r\n /// @notice Grants roles to the specified addresses\r\n /// @notice This function can only be called by the DAO\r\n /// @param roles The roles being granted\r\n /// @param members Addresses being granted each specified role\r\n function daoGrantRoles(string[] memory roles, address[][] memory members)\r\n external;\r\n\r\n /// @notice Authorizes roles to execute the specified actions\r\n /// @notice This function can only be called by the DAO\r\n /// @param targets The contract addresses that the action functions are implemented on\r\n /// @param functionDescs The function descriptions used to define the actions\r\n /// @param roles Roles being granted permission for an action\r\n function daoAddActionsRoles(\r\n address[] memory targets,\r\n string[] memory functionDescs,\r\n string[][] memory roles\r\n ) external;\r\n\r\n /// @notice Removes autorization for roles to execute the specified actions\r\n /// @notice This function can only be called by the DAO\r\n /// @param targets The contract addresses that the action functions are implemented on\r\n /// @param functionDescs The function description used to define the actions\r\n /// @param roles Roles that action permissions are being removed on\r\n function daoRemoveActionsRoles(\r\n address[] memory targets,\r\n string[] memory functionDescs,\r\n string[][] memory roles\r\n ) external;\r\n\r\n /// @notice Grants a role to the specified address\r\n /// @notice This function can only be called by an admin of the specified role\r\n /// @param role The role being granted\r\n /// @param account The address being granted the specified role\r\n function adminGrantRole(string memory role, address account)\r\n external;\r\n\r\n /// @notice Revokes a role from the specified address\r\n /// @notice This function can only be called by an admin of the specified role\r\n /// @param role The role being revoked\r\n /// @param account The address the role is being revoked from\r\n function adminRevokeRole(string memory role, address account)\r\n external;\r\n\r\n /// @notice Enables an address to remove one of its own roles\r\n /// @notice This function can only be called by the account specified\r\n /// @param role The role being renounced\r\n /// @param account The address renouncing the role\r\n function userRenounceRole(string memory role, address account) external;\r\n\r\n /// @notice Checks if a caller has the permissions to execute the specific action\r\n /// @param caller Address attempting to execute the action\r\n /// @param target Contract address corresponding to the action\r\n /// @param sig The function signature used to define the action\r\n function actionIsAuthorized(\r\n address caller,\r\n address target,\r\n bytes4 sig\r\n ) external view returns (bool isAuthorized);\r\n\r\n /// @notice Returns the roles autorized to execute the specified action\r\n /// @param target Contract address corresponding to the action\r\n /// @param functionDesc The function description used to define the action\r\n function getActionRoles(address target, string memory functionDesc)\r\n external\r\n view\r\n returns (string[] memory roles);\r\n\r\n /// @notice Checks if a specific role is authorized for an action\r\n /// @param role Role that authorization is being checked on\r\n /// @param target Contract address corresponding to the action\r\n /// @param functionDesc Function description used to define the action\r\n /// @return isAuthorized Indicates whether the role is authorized to execute the action\r\n function isRoleAuthorized(\r\n string calldata role,\r\n address target,\r\n string memory functionDesc\r\n ) external view returns (bool isAuthorized);\r\n\r\n /// @notice Returns whether the account has been granted the role\r\n /// @param role Role that authorization is being checked on\r\n /// @param account Address that the role authorization is being check on\r\n /// @return boolean Indicates whether the address has been granted the role\r\n function hasRole(string memory role, address account)\r\n external\r\n view\r\n returns (bool);\r\n\r\n /// @notice Returns the role that is the admin of the specified role\r\n /// @param role Role that the admin role is being returned for\r\n /// @return string The admin role of the specified role\r\n function getRoleAdmin(string memory role)\r\n external\r\n view\r\n returns (string memory);\r\n\r\n /// @return string The string \"DAO_ROLE\"\r\n function DAO_ROLE() external view returns (string memory);\r\n}\r\n" - }, - "contracts/GnosisWrapperFactory.sol": { - "content": "//SPDX-License-Identifier: Unlicense\npragma solidity ^0.8.0;\n\nimport \"@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol\";\nimport \"@openzeppelin/contracts/utils/Create2.sol\";\nimport \"./GnosisWrapper.sol\";\n\nimport \"@fractal-framework/core-contracts/contracts/ModuleFactoryBase.sol\";\n\n/// @dev GnosisWrapper Factory used to deploy Gnosis Modules\ncontract GnosisWrapperFactory is ModuleFactoryBase {\n event GnosisWrapperCreated(address gnosisSafe);\n\n function initialize() external initializer {\n __initFactoryBase();\n }\n\n /// @dev Creates a GnosisWrapper module\n /// @param creator The address creating the module\n /// @param data The array of bytes used to create the module\n /// @return address[] The array of addresses of the created module\n function create(address creator, bytes[] calldata data)\n external\n override\n returns (address[] memory)\n {\n address[] memory createdContracts = new address[](1);\n\n createdContracts[0] = createGnosisWrapper(creator, data);\n\n emit GnosisWrapperCreated(createdContracts[0]);\n\n return createdContracts;\n }\n\n function createGnosisWrapper(address creator, bytes[] memory data)\n private\n returns (address gnosisWrapper)\n {\n // Create wrapper\n gnosisWrapper = Create2.deploy(\n 0,\n keccak256(\n abi.encodePacked(\n creator,\n msg.sender,\n block.chainid,\n abi.decode(data[3], (bytes32)) // random salt\n )\n ),\n abi.encodePacked(\n type(ERC1967Proxy).creationCode,\n abi.encode(address(abi.decode(data[2], (address))), \"\") // impl address\n )\n );\n\n GnosisWrapper(gnosisWrapper).initialize(\n abi.decode(data[0], (address)),\n abi.decode(data[1], (address))\n ); // access Control, gnosisSafe\n }\n}\n" - }, - "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (proxy/ERC1967/ERC1967Proxy.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../Proxy.sol\";\nimport \"./ERC1967Upgrade.sol\";\n\n/**\n * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an\n * implementation address that can be changed. This address is stored in storage in the location specified by\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the\n * implementation behind the proxy.\n */\ncontract ERC1967Proxy is Proxy, ERC1967Upgrade {\n /**\n * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.\n *\n * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded\n * function call, and allows initializing the storage of the proxy like a Solidity constructor.\n */\n constructor(address _logic, bytes memory _data) payable {\n _upgradeToAndCall(_logic, _data, false);\n }\n\n /**\n * @dev Returns the current implementation address.\n */\n function _implementation() internal view virtual override returns (address impl) {\n return ERC1967Upgrade._getImplementation();\n }\n}\n" - }, - "@openzeppelin/contracts/utils/Create2.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Create2.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Helper to make usage of the `CREATE2` EVM opcode easier and safer.\n * `CREATE2` can be used to compute in advance the address where a smart\n * contract will be deployed, which allows for interesting new mechanisms known\n * as 'counterfactual interactions'.\n *\n * See the https://eips.ethereum.org/EIPS/eip-1014#motivation[EIP] for more\n * information.\n */\nlibrary Create2 {\n /**\n * @dev Deploys a contract using `CREATE2`. The address where the contract\n * will be deployed can be known in advance via {computeAddress}.\n *\n * The bytecode for a contract can be obtained from Solidity with\n * `type(contractName).creationCode`.\n *\n * Requirements:\n *\n * - `bytecode` must not be empty.\n * - `salt` must have not been used for `bytecode` already.\n * - the factory must have a balance of at least `amount`.\n * - if `amount` is non-zero, `bytecode` must have a `payable` constructor.\n */\n function deploy(\n uint256 amount,\n bytes32 salt,\n bytes memory bytecode\n ) internal returns (address) {\n address addr;\n require(address(this).balance >= amount, \"Create2: insufficient balance\");\n require(bytecode.length != 0, \"Create2: bytecode length is zero\");\n /// @solidity memory-safe-assembly\n assembly {\n addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt)\n }\n require(addr != address(0), \"Create2: Failed on deploy\");\n return addr;\n }\n\n /**\n * @dev Returns the address where a contract will be stored if deployed via {deploy}. Any change in the\n * `bytecodeHash` or `salt` will result in a new destination address.\n */\n function computeAddress(bytes32 salt, bytes32 bytecodeHash) internal view returns (address) {\n return computeAddress(salt, bytecodeHash, address(this));\n }\n\n /**\n * @dev Returns the address where a contract will be stored if deployed via {deploy} from a contract located at\n * `deployer`. If `deployer` is this contract's address, returns the same value as {computeAddress}.\n */\n function computeAddress(\n bytes32 salt,\n bytes32 bytecodeHash,\n address deployer\n ) internal pure returns (address) {\n bytes32 _data = keccak256(abi.encodePacked(bytes1(0xff), deployer, salt, bytecodeHash));\n return address(uint160(uint256(_data)));\n }\n}\n" - }, - "@fractal-framework/core-contracts/contracts/ModuleFactoryBase.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\r\nimport \"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\";\r\nimport \"@openzeppelin/contracts/utils/introspection/ERC165Storage.sol\";\r\nimport \"./interfaces/IModuleFactoryBase.sol\";\r\n\r\n/// @notice An abstract contract to be inherited by module contracts\r\nabstract contract ModuleFactoryBase is\r\n IModuleFactoryBase,\r\n Ownable,\r\n Initializable,\r\n ERC165Storage\r\n{\r\n VersionInfo[] public versionControl;\r\n\r\n /// @dev add a new version to update module users\r\n /// @param _semanticVersion semantic version control\r\n /// @param _frontendURI IPFS hash of the static frontend\r\n /// @param _impl address of the impl\r\n function addVersion(\r\n string calldata _semanticVersion,\r\n string calldata _frontendURI,\r\n address _impl\r\n ) external onlyOwner {\r\n versionControl.push(VersionInfo(_semanticVersion, _frontendURI, _impl));\r\n emit VersionCreated(_semanticVersion, _frontendURI, _impl);\r\n }\r\n\r\n /// @dev Creates a module\r\n /// @param creator The address creating the module\r\n /// @param data The array of bytes used to create the module\r\n /// @return address[] Array of the created module addresses\r\n function create(address creator, bytes[] calldata data)\r\n external\r\n virtual\r\n returns (address[] memory);\r\n\r\n /// @notice Function for initializing the contract that can only be called once\r\n function __initFactoryBase() internal onlyInitializing {\r\n _registerInterface(type(IModuleFactoryBase).interfaceId);\r\n }\r\n}\r\n" - }, - "@openzeppelin/contracts/proxy/Proxy.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\n * be specified by overriding the virtual {_implementation} function.\n *\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\n * different contract through the {_delegate} function.\n *\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\n */\nabstract contract Proxy {\n /**\n * @dev Delegates the current call to `implementation`.\n *\n * This function does not return to its internal call site, it will return directly to the external caller.\n */\n function _delegate(address implementation) internal virtual {\n assembly {\n // Copy msg.data. We take full control of memory in this inline assembly\n // block because it will not return to Solidity code. We overwrite the\n // Solidity scratch pad at memory position 0.\n calldatacopy(0, 0, calldatasize())\n\n // Call the implementation.\n // out and outsize are 0 because we don't know the size yet.\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\n\n // Copy the returned data.\n returndatacopy(0, 0, returndatasize())\n\n switch result\n // delegatecall returns 0 on error.\n case 0 {\n revert(0, returndatasize())\n }\n default {\n return(0, returndatasize())\n }\n }\n }\n\n /**\n * @dev This is a virtual function that should be overridden so it returns the address to which the fallback function\n * and {_fallback} should delegate.\n */\n function _implementation() internal view virtual returns (address);\n\n /**\n * @dev Delegates the current call to the address returned by `_implementation()`.\n *\n * This function does not return to its internal call site, it will return directly to the external caller.\n */\n function _fallback() internal virtual {\n _beforeFallback();\n _delegate(_implementation());\n }\n\n /**\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\n * function in the contract matches the call data.\n */\n fallback() external payable virtual {\n _fallback();\n }\n\n /**\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\n * is empty.\n */\n receive() external payable virtual {\n _fallback();\n }\n\n /**\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\n * call, or as part of the Solidity `fallback` or `receive` functions.\n *\n * If overridden should call `super._beforeFallback()`.\n */\n function _beforeFallback() internal virtual {}\n}\n" - }, - "@openzeppelin/contracts/proxy/ERC1967/ERC1967Upgrade.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../beacon/IBeacon.sol\";\nimport \"../../interfaces/draft-IERC1822.sol\";\nimport \"../../utils/Address.sol\";\nimport \"../../utils/StorageSlot.sol\";\n\n/**\n * @dev This abstract contract provides getters and event emitting update functions for\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.\n *\n * _Available since v4.1._\n *\n * @custom:oz-upgrades-unsafe-allow delegatecall\n */\nabstract contract ERC1967Upgrade {\n // This is the keccak-256 hash of \"eip1967.proxy.rollback\" subtracted by 1\n bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;\n\n /**\n * @dev Storage slot with the address of the current implementation.\n * This is the keccak-256 hash of \"eip1967.proxy.implementation\" subtracted by 1, and is\n * validated in the constructor.\n */\n bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n /**\n * @dev Emitted when the implementation is upgraded.\n */\n event Upgraded(address indexed implementation);\n\n /**\n * @dev Returns the current implementation address.\n */\n function _getImplementation() internal view returns (address) {\n return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n }\n\n /**\n * @dev Stores a new address in the EIP1967 implementation slot.\n */\n function _setImplementation(address newImplementation) private {\n require(Address.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n }\n\n /**\n * @dev Perform implementation upgrade\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeTo(address newImplementation) internal {\n _setImplementation(newImplementation);\n emit Upgraded(newImplementation);\n }\n\n /**\n * @dev Perform implementation upgrade with additional setup call.\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeToAndCall(\n address newImplementation,\n bytes memory data,\n bool forceCall\n ) internal {\n _upgradeTo(newImplementation);\n if (data.length > 0 || forceCall) {\n Address.functionDelegateCall(newImplementation, data);\n }\n }\n\n /**\n * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeToAndCallUUPS(\n address newImplementation,\n bytes memory data,\n bool forceCall\n ) internal {\n // Upgrades from old implementations will perform a rollback test. This test requires the new\n // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing\n // this special case will break upgrade paths from old UUPS implementation to new ones.\n if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {\n _setImplementation(newImplementation);\n } else {\n try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {\n require(slot == _IMPLEMENTATION_SLOT, \"ERC1967Upgrade: unsupported proxiableUUID\");\n } catch {\n revert(\"ERC1967Upgrade: new implementation is not UUPS\");\n }\n _upgradeToAndCall(newImplementation, data, forceCall);\n }\n }\n\n /**\n * @dev Storage slot with the admin of the contract.\n * This is the keccak-256 hash of \"eip1967.proxy.admin\" subtracted by 1, and is\n * validated in the constructor.\n */\n bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\n\n /**\n * @dev Emitted when the admin account has changed.\n */\n event AdminChanged(address previousAdmin, address newAdmin);\n\n /**\n * @dev Returns the current admin.\n */\n function _getAdmin() internal view returns (address) {\n return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;\n }\n\n /**\n * @dev Stores a new address in the EIP1967 admin slot.\n */\n function _setAdmin(address newAdmin) private {\n require(newAdmin != address(0), \"ERC1967: new admin is the zero address\");\n StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;\n }\n\n /**\n * @dev Changes the admin of the proxy.\n *\n * Emits an {AdminChanged} event.\n */\n function _changeAdmin(address newAdmin) internal {\n emit AdminChanged(_getAdmin(), newAdmin);\n _setAdmin(newAdmin);\n }\n\n /**\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\n */\n bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\n\n /**\n * @dev Emitted when the beacon is upgraded.\n */\n event BeaconUpgraded(address indexed beacon);\n\n /**\n * @dev Returns the current beacon.\n */\n function _getBeacon() internal view returns (address) {\n return StorageSlot.getAddressSlot(_BEACON_SLOT).value;\n }\n\n /**\n * @dev Stores a new beacon in the EIP1967 beacon slot.\n */\n function _setBeacon(address newBeacon) private {\n require(Address.isContract(newBeacon), \"ERC1967: new beacon is not a contract\");\n require(\n Address.isContract(IBeacon(newBeacon).implementation()),\n \"ERC1967: beacon implementation is not a contract\"\n );\n StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;\n }\n\n /**\n * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does\n * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).\n *\n * Emits a {BeaconUpgraded} event.\n */\n function _upgradeBeaconToAndCall(\n address newBeacon,\n bytes memory data,\n bool forceCall\n ) internal {\n _setBeacon(newBeacon);\n emit BeaconUpgraded(newBeacon);\n if (data.length > 0 || forceCall) {\n Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);\n }\n }\n}\n" - }, - "@openzeppelin/contracts/proxy/beacon/IBeacon.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\n */\ninterface IBeacon {\n /**\n * @dev Must return an address that can be used as a delegate call target.\n *\n * {BeaconProxy} will check that this address is a contract.\n */\n function implementation() external view returns (address);\n}\n" - }, - "@openzeppelin/contracts/interfaces/draft-IERC1822.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified\n * proxy whose upgrades are fully controlled by the current implementation.\n */\ninterface IERC1822Proxiable {\n /**\n * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation\n * address.\n *\n * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\n * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\n * function revert if invoked through a proxy.\n */\n function proxiableUUID() external view returns (bytes32);\n}\n" - }, - "@openzeppelin/contracts/utils/Address.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n /**\n * @dev Returns true if `account` is a contract.\n *\n * [IMPORTANT]\n * ====\n * It is unsafe to assume that an address for which this function returns\n * false is an externally-owned account (EOA) and not a contract.\n *\n * Among others, `isContract` will return false for the following\n * types of addresses:\n *\n * - an externally-owned account\n * - a contract in construction\n * - an address where a contract will be created\n * - an address where a contract lived, but was destroyed\n * ====\n *\n * [IMPORTANT]\n * ====\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\n *\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n * constructor.\n * ====\n */\n function isContract(address account) internal view returns (bool) {\n // This method relies on extcodesize/address.code.length, which returns 0\n // for contracts in construction, since the code is only stored at the end\n // of the constructor execution.\n\n return account.code.length > 0;\n }\n\n /**\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n * `recipient`, forwarding all available gas and reverting on errors.\n *\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\n * imposed by `transfer`, making them unable to receive funds via\n * `transfer`. {sendValue} removes this limitation.\n *\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n *\n * IMPORTANT: because control is transferred to `recipient`, care must be\n * taken to not create reentrancy vulnerabilities. Consider using\n * {ReentrancyGuard} or the\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n */\n function sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n (bool success, ) = recipient.call{value: amount}(\"\");\n require(success, \"Address: unable to send value, recipient may have reverted\");\n }\n\n /**\n * @dev Performs a Solidity function call using a low level `call`. A\n * plain `call` is an unsafe replacement for a function call: use this\n * function instead.\n *\n * If `target` reverts with a revert reason, it is bubbled up by this\n * function (like regular Solidity function calls).\n *\n * Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n *\n * Requirements:\n *\n * - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCall(target, data, \"Address: low-level call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n * `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n *\n * Requirements:\n *\n * - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n * with `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value,\n string memory errorMessage\n ) internal returns (bytes memory) {\n require(address(this).balance >= value, \"Address: insufficient balance for call\");\n require(isContract(target), \"Address: call to non-contract\");\n\n (bool success, bytes memory returndata) = target.call{value: value}(data);\n return verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, \"Address: low-level static call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal view returns (bytes memory) {\n require(isContract(target), \"Address: static call to non-contract\");\n\n (bool success, bytes memory returndata) = target.staticcall(data);\n return verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n require(isContract(target), \"Address: delegate call to non-contract\");\n\n (bool success, bytes memory returndata) = target.delegatecall(data);\n return verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\n * revert reason using the provided one.\n *\n * _Available since v4.3._\n */\n function verifyCallResult(\n bool success,\n bytes memory returndata,\n string memory errorMessage\n ) internal pure returns (bytes memory) {\n if (success) {\n return returndata;\n } else {\n // Look for revert reason and bubble it up if present\n if (returndata.length > 0) {\n // The easiest way to bubble the revert reason is using memory via assembly\n /// @solidity memory-safe-assembly\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(errorMessage);\n }\n }\n }\n}\n" - }, - "@openzeppelin/contracts/utils/StorageSlot.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Library for reading and writing primitive types to specific storage slots.\n *\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\n * This library helps with reading and writing to such slots without the need for inline assembly.\n *\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\n *\n * Example usage to set ERC1967 implementation slot:\n * ```\n * contract ERC1967 {\n * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n *\n * function _getImplementation() internal view returns (address) {\n * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n * }\n *\n * function _setImplementation(address newImplementation) internal {\n * require(Address.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n * }\n * }\n * ```\n *\n * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._\n */\nlibrary StorageSlot {\n struct AddressSlot {\n address value;\n }\n\n struct BooleanSlot {\n bool value;\n }\n\n struct Bytes32Slot {\n bytes32 value;\n }\n\n struct Uint256Slot {\n uint256 value;\n }\n\n /**\n * @dev Returns an `AddressSlot` with member `value` located at `slot`.\n */\n function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\n */\n function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\n */\n function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\n */\n function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n }\n}\n" - }, - "@openzeppelin/contracts/access/Ownable.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n address private _owner;\n\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n /**\n * @dev Initializes the contract setting the deployer as the initial owner.\n */\n constructor() {\n _transferOwnership(_msgSender());\n }\n\n /**\n * @dev Throws if called by any account other than the owner.\n */\n modifier onlyOwner() {\n _checkOwner();\n _;\n }\n\n /**\n * @dev Returns the address of the current owner.\n */\n function owner() public view virtual returns (address) {\n return _owner;\n }\n\n /**\n * @dev Throws if the sender is not the owner.\n */\n function _checkOwner() internal view virtual {\n require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n }\n\n /**\n * @dev Leaves the contract without owner. It will not be possible to call\n * `onlyOwner` functions anymore. Can only be called by the current owner.\n *\n * NOTE: Renouncing ownership will leave the contract without an owner,\n * thereby removing any functionality that is only available to the owner.\n */\n function renounceOwnership() public virtual onlyOwner {\n _transferOwnership(address(0));\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Can only be called by the current owner.\n */\n function transferOwnership(address newOwner) public virtual onlyOwner {\n require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n _transferOwnership(newOwner);\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Internal function without access restriction.\n */\n function _transferOwnership(address newOwner) internal virtual {\n address oldOwner = _owner;\n _owner = newOwner;\n emit OwnershipTransferred(oldOwner, newOwner);\n }\n}\n" - }, - "@fractal-framework/core-contracts/contracts/interfaces/IModuleFactoryBase.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\n/// @dev The interface to be inherited by Fractal module factories\r\ninterface IModuleFactoryBase {\r\n event VersionCreated(\r\n string semanticVersion,\r\n string frontendURI,\r\n address impl\r\n );\r\n struct VersionInfo {\r\n string semanticVersion;\r\n string frontendURI;\r\n address impl;\r\n }\r\n\r\n /// @dev add a new version to update module users\r\n /// @param _semanticVersion semantic version control\r\n /// @param _frontendURI IPFS hash of the static frontend\r\n /// @param _impl address of the impl\r\n function addVersion(\r\n string calldata _semanticVersion,\r\n string calldata _frontendURI,\r\n address _impl\r\n ) external;\r\n\r\n /// @dev Creates a module\r\n /// @param creator The address creating the module\r\n /// @param data The array of bytes used to create the module\r\n /// @return address[] Array of the created module addresses\r\n function create(address creator, bytes[] calldata data)\r\n external\r\n returns (address[] memory);\r\n}\r\n" - }, - "@openzeppelin/contracts/utils/Context.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n function _msgSender() internal view virtual returns (address) {\n return msg.sender;\n }\n\n function _msgData() internal view virtual returns (bytes calldata) {\n return msg.data;\n }\n}\n" - }, - "contracts/mocks/MetaFactory.sol": { - "content": "//SPDX-License-Identifier: Unlicense\npragma solidity ^0.8.0;\n\nimport \"@openzeppelin/contracts/utils/introspection/ERC165.sol\";\nimport \"@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol\";\nimport \"@openzeppelin/contracts/utils/Address.sol\";\nimport \"@openzeppelin/contracts-upgradeable/governance/utils/IVotesUpgradeable.sol\";\nimport \"@openzeppelin/contracts/utils/Address.sol\";\n\nimport \"./interfaces/IMetaFactory.sol\";\nimport \"@fractal-framework/core-contracts/contracts/interfaces/IDAO.sol\";\nimport \"@fractal-framework/core-contracts/contracts/interfaces/IModuleFactoryBase.sol\";\n\n/// @notice A factory contract for deploying DAOs along with any desired modules within one transaction\n/// @dev For the Metafactory to be able to call the execute function on the created DAO, it needs to be given\n/// @dev a role that has permissions to call this function. It is critical to have the MetaFactory then revoke\n/// @dev this role within the same transaction, so that the MetaFactory cannot be used to perform arbitrary\n/// @dev execution calls on the DAO in the future.\ncontract MetaFactory is IMetaFactory, ERC165 {\n /// @notice Creates a DAO, Access Control, and any modules specified\n /// @param daoFactory The address of the DAO factory\n /// @param createDAOParams The struct of parameters used for creating the DAO and Access Control contracts\n /// @param moduleFactories Array of addresses of the module factories to call\n /// @param moduleFactoriesBytes Array of array of bytes to pass to module factory calls\n /// @param targets An array of addresses to target for the function calls\n /// @param values An array of ether values to send with the function calls\n /// @param calldatas An array of bytes defining the function calls\n function createDAOAndExecute(\n address daoFactory,\n IDAOFactory.CreateDAOParams memory createDAOParams,\n address[] calldata moduleFactories,\n bytes[][] calldata moduleFactoriesBytes,\n address[] calldata targets,\n uint256[] calldata values,\n bytes[] calldata calldatas\n ) external {\n createDAO(daoFactory, createDAOParams);\n createModules(moduleFactories, moduleFactoriesBytes);\n execute(targets, values, calldatas);\n }\n\n /// @notice A function for creating the DAO and Access Control contracts\n /// @param daoFactory The address of the DAO factory\n /// @param createDAOParams The struct of parameters used for creating the DAO and Access Control contracts\n function createDAO(\n address daoFactory,\n IDAOFactory.CreateDAOParams memory createDAOParams\n ) internal {\n (address dao, address accessControl) = IDAOFactory(daoFactory)\n .createDAO(msg.sender, createDAOParams);\n\n emit DAOCreated(dao, accessControl, msg.sender);\n }\n\n function createModules(\n address[] calldata moduleFactories,\n bytes[][] calldata moduleFactoriesBytes\n ) internal {\n if (moduleFactories.length != moduleFactoriesBytes.length)\n revert UnequalArrayLengths();\n\n for (uint256 i; i < moduleFactories.length; i++) {\n IModuleFactoryBase(moduleFactories[i]).create(\n msg.sender,\n moduleFactoriesBytes[i]\n );\n }\n }\n\n /// @notice A function for executing function calls to deploy an MVD, modules, and initialize them\n /// @param targets An array of addresses to target for the function calls\n /// @param values An array of ether values to send with the function calls\n /// @param calldatas An array of bytes defining the function calls\n function execute(\n address[] calldata targets,\n uint256[] calldata values,\n bytes[] calldata calldatas\n ) internal {\n if (\n targets.length != values.length ||\n targets.length != calldatas.length\n ) revert UnequalArrayLengths();\n string\n memory errorMessage = \"MetaFactory: call reverted without message\";\n uint256 targetlength = targets.length;\n for (uint256 i = 0; i < targetlength; ) {\n (bool success, bytes memory returndata) = targets[i].call{\n value: values[i]\n }(calldatas[i]);\n Address.verifyCallResult(success, returndata, errorMessage);\n unchecked {\n i++;\n }\n }\n emit Executed(targets, values, calldatas);\n }\n\n /// @notice Returns whether a given interface ID is supported\n /// @param interfaceId An interface ID bytes4 as defined by ERC-165\n /// @return bool Indicates whether the interface is supported\n function supportsInterface(bytes4 interfaceId)\n public\n view\n virtual\n override\n returns (bool)\n {\n return\n interfaceId == type(IMetaFactory).interfaceId ||\n super.supportsInterface(interfaceId);\n }\n}\n" - }, - "@openzeppelin/contracts-upgradeable/governance/utils/IVotesUpgradeable.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (governance/utils/IVotes.sol)\npragma solidity ^0.8.0;\n\n/**\n * @dev Common interface for {ERC20Votes}, {ERC721Votes}, and other {Votes}-enabled contracts.\n *\n * _Available since v4.5._\n */\ninterface IVotesUpgradeable {\n /**\n * @dev Emitted when an account changes their delegate.\n */\n event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);\n\n /**\n * @dev Emitted when a token transfer or delegate change results in changes to a delegate's number of votes.\n */\n event DelegateVotesChanged(address indexed delegate, uint256 previousBalance, uint256 newBalance);\n\n /**\n * @dev Returns the current amount of votes that `account` has.\n */\n function getVotes(address account) external view returns (uint256);\n\n /**\n * @dev Returns the amount of votes that `account` had at the end of a past block (`blockNumber`).\n */\n function getPastVotes(address account, uint256 blockNumber) external view returns (uint256);\n\n /**\n * @dev Returns the total supply of votes available at the end of a past block (`blockNumber`).\n *\n * NOTE: This value is the sum of all available votes, which is not necessarily the sum of all delegated votes.\n * Votes that have not been delegated are still part of total supply, even though they would not participate in a\n * vote.\n */\n function getPastTotalSupply(uint256 blockNumber) external view returns (uint256);\n\n /**\n * @dev Returns the delegate that `account` has chosen.\n */\n function delegates(address account) external view returns (address);\n\n /**\n * @dev Delegates votes from the sender to `delegatee`.\n */\n function delegate(address delegatee) external;\n\n /**\n * @dev Delegates votes from signer to `delegatee`.\n */\n function delegateBySig(\n address delegatee,\n uint256 nonce,\n uint256 expiry,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) external;\n}\n" - }, - "contracts/mocks/interfaces/IMetaFactory.sol": { - "content": "//SPDX-License-Identifier: Unlicense\npragma solidity ^0.8.0;\n\nimport \"@fractal-framework/core-contracts/contracts/interfaces/IDAOFactory.sol\";\n\ninterface IMetaFactory {\n event DAOCreated(address indexed daoAddress, address indexed accessControl, address indexed creator);\n event Executed(address[] targets, uint256[] values, bytes[] calldatas);\n\n error UnequalArrayLengths();\n\n /// @notice Creates a DAO, Access Control, and any modules specified\n /// @param daoFactory The address of the DAO factory\n /// @param createDAOParams The struct of parameters used for creating the DAO and Access Control contracts\n /// @param moduleFactories Array of addresses of the module factories to call\n /// @param moduleFactoriesBytes Array of array of bytes to pass to module factory calls\n /// @param targets An array of addresses to target for the function calls\n /// @param values An array of ether values to send with the function calls\n /// @param calldatas An array of bytes defining the function calls\n function createDAOAndExecute(\n address daoFactory,\n IDAOFactory.CreateDAOParams memory createDAOParams,\n address[] calldata moduleFactories,\n bytes[][] calldata moduleFactoriesBytes,\n address[] calldata targets,\n uint256[] calldata values,\n bytes[] calldata calldatas\n ) external;\n}\n" - }, - "@fractal-framework/core-contracts/contracts/interfaces/IDAO.sol": { - "content": "import \"./IModuleBase.sol\";\r\n\r\n//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\ninterface IDAO {\r\n error Unauthorized(bytes32 role, address account);\r\n error UnequalArrayLengths();\r\n\r\n event Executed(address[] targets, uint256[] values, bytes[] calldatas);\r\n\r\n /// @notice Function for initializing the Dao\r\n /// @param _accessControl The address of the access control contract\r\n /// @param _moduleFactory The address of the module factory\r\n /// @param _name Name of the Dao\r\n function initialize(address _accessControl, address _moduleFactory, string calldata _name) external;\r\n\r\n /// @notice A function for executing function calls from the DAO\r\n /// @param targets An array of addresses to target for the function calls\r\n /// @param values An array of ether values to send with the function calls\r\n /// @param calldatas An array of bytes defining the function calls\r\n function execute(\r\n address[] calldata targets,\r\n uint256[] calldata values,\r\n bytes[] calldata calldatas\r\n ) external;\r\n}\r\n" - }, - "@fractal-framework/core-contracts/contracts/interfaces/IDAOFactory.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\ninterface IDAOFactory {\r\n struct CreateDAOParams {\r\n address daoImplementation;\r\n address accessControlImplementation;\r\n bytes32 salt;\r\n string daoName;\r\n string[] roles;\r\n string[] rolesAdmins;\r\n address[][] members;\r\n string[] daoFunctionDescs;\r\n string[][] daoActionRoles;\r\n }\r\n\r\n event DAOCreated(address indexed daoAddress, address accessControl, address indexed sender, address indexed creator);\r\n\r\n /// @notice Creates a DAO with an access control contract\r\n /// @param creator Address of the Dao Creator\r\n /// @param createDAOParams Struct of all the parameters required to create a DAO\r\n /// @return dao The address of the deployed DAO proxy contract\r\n /// @return accessControl The address of the deployed access control proxy contract\r\n function createDAO(address creator, CreateDAOParams calldata createDAOParams)\r\n external\r\n returns (address, address);\r\n}\r\n" - }, - "@fractal-framework/core-contracts/contracts/DAOFactory.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\nimport \"@openzeppelin/contracts/utils/introspection/ERC165Storage.sol\";\r\nimport \"@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol\";\r\nimport \"@openzeppelin/contracts/utils/Create2.sol\";\r\n\r\nimport \"./interfaces/IDAOFactory.sol\";\r\nimport \"./interfaces/IDAOAccessControl.sol\";\r\nimport \"./interfaces/IDAO.sol\";\r\n\r\n/// @notice A factory contract for deploying DAOs with an access control contract\r\ncontract DAOFactory is IDAOFactory, ERC165Storage {\r\n constructor() {\r\n _registerInterface(type(IDAOFactory).interfaceId);\r\n }\r\n\r\n /// @notice Creates a DAO with an access control contract\r\n /// @param creator Address of the Dao Creator\r\n /// @param createDAOParams Struct of all the parameters required to create a DAO\r\n /// @return dao The address of the deployed DAO proxy contract\r\n /// @return accessControl The address of the deployed access control proxy contract\r\n function createDAO(\r\n address creator,\r\n CreateDAOParams calldata createDAOParams\r\n ) external returns (address dao, address accessControl) {\r\n dao = _createDAO(creator, createDAOParams);\r\n accessControl = _createAccessControl(creator, createDAOParams);\r\n\r\n address[] memory targets = new address[](\r\n createDAOParams.daoFunctionDescs.length\r\n );\r\n\r\n for (uint256 i; i < createDAOParams.daoFunctionDescs.length; ) {\r\n targets[i] = dao;\r\n unchecked {\r\n i++;\r\n }\r\n }\r\n\r\n IDAO(dao).initialize(\r\n accessControl,\r\n address(this),\r\n createDAOParams.daoName\r\n );\r\n IDAOAccessControl(accessControl).initialize(\r\n dao,\r\n createDAOParams.roles,\r\n createDAOParams.rolesAdmins,\r\n createDAOParams.members,\r\n targets,\r\n createDAOParams.daoFunctionDescs,\r\n createDAOParams.daoActionRoles\r\n );\r\n\r\n emit DAOCreated(dao, accessControl, msg.sender, creator);\r\n }\r\n\r\n /// @notice Creates a DAO contract\r\n /// @param creator Address of the Dao Creator\r\n /// @param createDAOParams Struct of all the parameters required to create a DAO\r\n /// @return _dao The address of the deployed DAO proxy contract\r\n function _createDAO(address creator, CreateDAOParams calldata createDAOParams)\r\n internal\r\n returns (address _dao)\r\n {\r\n _dao = Create2.deploy(\r\n 0,\r\n keccak256(abi.encodePacked(creator, msg.sender, block.chainid, createDAOParams.salt)),\r\n abi.encodePacked(\r\n type(ERC1967Proxy).creationCode,\r\n abi.encode(createDAOParams.daoImplementation, \"\")\r\n )\r\n );\r\n }\r\n\r\n /// @notice Creates a an access control contract\r\n /// @param creator Address of the Dao Creator\r\n /// @param createDAOParams Struct of all the parameters required to create a DAO\r\n /// @return _accessControl The address of the deployed access control proxy contract\r\n function _createAccessControl(address creator, CreateDAOParams memory createDAOParams)\r\n internal\r\n returns (address _accessControl)\r\n {\r\n _accessControl = Create2.deploy(\r\n 0,\r\n keccak256(abi.encodePacked(creator, msg.sender, block.chainid, createDAOParams.salt)),\r\n abi.encodePacked(\r\n type(ERC1967Proxy).creationCode,\r\n abi.encode(createDAOParams.accessControlImplementation, \"\")\r\n )\r\n );\r\n }\r\n}\r\n" - }, - "@fractal-framework/core-contracts/contracts/DAOAccessControl.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\nimport \"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\";\r\nimport \"@openzeppelin/contracts/utils/introspection/ERC165Storage.sol\";\r\n\r\nimport \"./interfaces/IDAOAccessControl.sol\";\r\n\r\n/// @title DAO Access Control\r\n/// @notice Use this contract for managing DAO role based permissions\r\ncontract DAOAccessControl is IDAOAccessControl, ERC165Storage, UUPSUpgradeable {\r\n string public constant DAO_ROLE = \"DAO_ROLE\";\r\n string public constant OPEN_ROLE = \"OPEN_ROLE\";\r\n\r\n mapping(string => RoleData) private _roles;\r\n mapping(address => mapping(bytes4 => string[])) private _actionsToRoles;\r\n\r\n /// @notice Modifier that checks that an account has a specific role. Reverts\r\n /// with a standardized message including the required role.\r\n modifier onlyRole(string memory role) {\r\n _checkRole(role, msg.sender);\r\n _;\r\n }\r\n\r\n /// @notice Initialize DAO action and role permissions\r\n /// @param dao Address to receive DAO role\r\n /// @param roles What permissions are assigned to\r\n /// @param roleAdmins Roles which have the ability to remove or add members\r\n /// @param members Addresses to be granted the specified roles\r\n /// @param targets Contract addresses for actions to be defined on\r\n /// @param functionDescs Function descriptions used to define actions\r\n /// @param actionRoles Roles being granted permission for an action\r\n function initialize(\r\n address dao,\r\n string[] memory roles,\r\n string[] memory roleAdmins,\r\n address[][] memory members,\r\n address[] memory targets,\r\n string[] memory functionDescs,\r\n string[][] memory actionRoles\r\n ) external initializer {\r\n if (\r\n roles.length != roleAdmins.length ||\r\n roles.length != members.length ||\r\n targets.length != functionDescs.length ||\r\n targets.length != actionRoles.length\r\n ) revert UnequalArrayLengths();\r\n\r\n _grantRole(DAO_ROLE, dao);\r\n _grantRolesAndAdmins(roles, roleAdmins, members);\r\n _addActionsRoles(targets, functionDescs, actionRoles);\r\n __UUPSUpgradeable_init();\r\n _registerInterface(type(IDAOAccessControl).interfaceId);\r\n }\r\n\r\n /// @notice Grants roles to the specified addresses and defines admin roles\r\n /// @notice This function can only be called by the DAO\r\n /// @param roles The roles being granted\r\n /// @param roleAdmins The roles being granted as admins of the specified of roles\r\n /// @param members Addresses being granted each specified role\r\n function daoGrantRolesAndAdmins(\r\n string[] memory roles,\r\n string[] memory roleAdmins,\r\n address[][] memory members\r\n ) external onlyRole(DAO_ROLE) {\r\n _grantRolesAndAdmins(roles, roleAdmins, members);\r\n }\r\n\r\n /// @notice Grants roles to the specified addresses\r\n /// @notice This function can only be called by the DAO\r\n /// @param roles The roles being granted\r\n /// @param members Addresses being granted each specified role\r\n function daoGrantRoles(string[] memory roles, address[][] memory members)\r\n external\r\n onlyRole(DAO_ROLE)\r\n {\r\n _grantRoles(roles, members);\r\n }\r\n\r\n /// @notice Authorizes roles to execute the specified actions\r\n /// @notice This function can only be called by the DAO\r\n /// @param targets The contract addresses that the action functions are implemented on\r\n /// @param functionDescs The function descriptions used to define the actions\r\n /// @param roles Roles being granted permission for an action\r\n function daoAddActionsRoles(\r\n address[] memory targets,\r\n string[] memory functionDescs,\r\n string[][] memory roles\r\n ) external onlyRole(DAO_ROLE) {\r\n _addActionsRoles(targets, functionDescs, roles);\r\n }\r\n\r\n /// @notice Removes autorization for roles to execute the specified actions\r\n /// @notice This function can only be called by the DAO\r\n /// @param targets The contract addresses that the action functions are implemented on\r\n /// @param functionDescs The function description used to define the actions\r\n /// @param roles Roles that action permissions are being removed on\r\n function daoRemoveActionsRoles(\r\n address[] memory targets,\r\n string[] memory functionDescs,\r\n string[][] memory roles\r\n ) external onlyRole(DAO_ROLE) {\r\n if (targets.length != functionDescs.length)\r\n revert UnequalArrayLengths();\r\n if (targets.length != roles.length) revert UnequalArrayLengths();\r\n uint256 actionsLength = targets.length;\r\n for (uint256 i = 0; i < actionsLength; ) {\r\n uint256 rolesLength = roles[i].length;\r\n for (uint256 j = 0; j < rolesLength; ) {\r\n _removeActionRole(targets[i], functionDescs[i], roles[i][j]);\r\n unchecked {\r\n j++;\r\n }\r\n }\r\n unchecked {\r\n i++;\r\n }\r\n }\r\n }\r\n\r\n /// @notice Grants a role to the specified address\r\n /// @notice This function can only be called by an admin of the specified role\r\n /// @param role The role being granted\r\n /// @param account The address being granted the specified role\r\n function adminGrantRole(string memory role, address account)\r\n external\r\n onlyRole(getRoleAdmin(role))\r\n {\r\n _grantRole(role, account);\r\n }\r\n\r\n /// @notice Revokes a role from the specified address\r\n /// @notice This function can only be called by an admin of the specified role\r\n /// @param role The role being revoked\r\n /// @param account The address the role is being revoked from\r\n function adminRevokeRole(string memory role, address account)\r\n external\r\n onlyRole(getRoleAdmin(role))\r\n {\r\n _revokeRole(role, account);\r\n }\r\n\r\n /// @notice Enables an address to remove one of its own roles\r\n /// @notice This function can only be called by the account specified\r\n /// @param role The role being renounced\r\n /// @param account The address renouncing the role\r\n function userRenounceRole(string memory role, address account) external {\r\n if (account != msg.sender) {\r\n revert OnlySelfRenounce();\r\n }\r\n\r\n _revokeRole(role, account);\r\n } \r\n\r\n /// @notice Checks if a caller has the permissions to execute the specific action\r\n /// @param caller Address attempting to execute the action\r\n /// @param target Contract address corresponding to the action\r\n /// @param sig The function signature used to define the action\r\n function actionIsAuthorized(\r\n address caller,\r\n address target,\r\n bytes4 sig\r\n ) external view returns (bool isAuthorized) {\r\n string[] memory roles = _actionsToRoles[target][sig];\r\n uint256 roleLength = roles.length;\r\n\r\n for (uint256 i = 0; i < roleLength; ) {\r\n if (hasRole(roles[i], caller)) {\r\n isAuthorized = true;\r\n break;\r\n }\r\n unchecked {\r\n i++;\r\n }\r\n }\r\n }\r\n\r\n /// @notice Returns the roles autorized to execute the specified action\r\n /// @param target Contract address corresponding to the action\r\n /// @param functionDesc The function description used to define the action\r\n function getActionRoles(address target, string memory functionDesc)\r\n external\r\n view\r\n returns (string[] memory roles)\r\n {\r\n bytes4 encodedSig = bytes4(keccak256(abi.encodePacked(functionDesc)));\r\n return _actionsToRoles[target][encodedSig];\r\n }\r\n\r\n /// @notice Checks if a specific role is authorized for an action\r\n /// @param role Role that authorization is being checked on\r\n /// @param target Contract address corresponding to the action\r\n /// @param functionDesc Function description used to define the action\r\n /// @return isAuthorized Indicates whether the role is authorized to execute the action\r\n function isRoleAuthorized(\r\n string calldata role,\r\n address target,\r\n string memory functionDesc\r\n ) external view returns (bool isAuthorized) {\r\n bytes4 encodedSig = bytes4(keccak256(abi.encodePacked(functionDesc)));\r\n string[] memory roles = _actionsToRoles[target][encodedSig];\r\n uint256 rolesLength = roles.length;\r\n\r\n for (uint256 i = 0; i < rolesLength; ) {\r\n if (\r\n keccak256(abi.encodePacked(role)) ==\r\n keccak256(abi.encodePacked(roles[i]))\r\n ) {\r\n isAuthorized = true;\r\n break;\r\n }\r\n unchecked {\r\n i++;\r\n }\r\n }\r\n }\r\n\r\n /// @notice Returns whether the account has been granted the role\r\n /// @param role Role that authorization is being checked on\r\n /// @param account Address that the role authorization is being check on\r\n /// @return boolean Indicates whether the address has been granted the role\r\n function hasRole(string memory role, address account)\r\n public\r\n view\r\n returns (bool)\r\n {\r\n if (\r\n keccak256(bytes(role)) ==\r\n keccak256(bytes(OPEN_ROLE))\r\n ) {\r\n return true;\r\n } else {\r\n return _roles[role].members[account];\r\n }\r\n }\r\n\r\n /// @notice Returns the role that is the admin of the specified role\r\n /// @param role Role that the admin role is being returned for\r\n /// @return string The admin role of the specified role\r\n function getRoleAdmin(string memory role)\r\n public\r\n view\r\n returns (string memory)\r\n {\r\n return _roles[role].adminRole;\r\n }\r\n\r\n /// @notice Sets a role as the admin of another role\r\n /// @param role The role the admin is being set for\r\n /// @param adminRole The role that is being assigned as an admin\r\n function _setRoleAdmin(string memory role, string memory adminRole)\r\n internal\r\n {\r\n string memory previousAdminRole = getRoleAdmin(role);\r\n _roles[role].adminRole = adminRole;\r\n emit RoleAdminChanged(role, previousAdminRole, adminRole);\r\n }\r\n\r\n /// @notice Grants a role to the specified address\r\n /// @param role The role being granted\r\n /// @param account The address being granted the specified role\r\n function _grantRole(string memory role, address account) internal {\r\n if (!hasRole(role, account)) {\r\n _roles[role].members[account] = true;\r\n emit RoleGranted(role, account, msg.sender);\r\n }\r\n }\r\n\r\n /// @notice Revokes a role from the specified address\r\n /// @param role The role being revoked\r\n /// @param account The address the role is being revoked from\r\n function _revokeRole(string memory role, address account) internal {\r\n if (hasRole(role, account)) {\r\n _roles[role].members[account] = false;\r\n emit RoleRevoked(role, account, msg.sender);\r\n }\r\n }\r\n\r\n /// @notice Grants roles to the specified addresses and defines admin roles\r\n /// @param roles The roles being granted\r\n /// @param roleAdmins The roles being granted as admins of the specified of roles\r\n /// @param members Addresses being granted each specified role\r\n function _grantRolesAndAdmins(\r\n string[] memory roles,\r\n string[] memory roleAdmins,\r\n address[][] memory members\r\n ) internal {\r\n if (roles.length != roleAdmins.length) revert UnequalArrayLengths();\r\n if (roles.length != members.length) revert UnequalArrayLengths();\r\n\r\n uint256 rolesLength = roles.length;\r\n for (uint256 i = 0; i < rolesLength; ) {\r\n _setRoleAdmin(roles[i], roleAdmins[i]);\r\n\r\n uint256 membersLength = members[i].length;\r\n for (uint256 j = 0; j < membersLength; ) {\r\n _grantRole(roles[i], members[i][j]);\r\n unchecked {\r\n j++;\r\n }\r\n }\r\n unchecked {\r\n i++;\r\n }\r\n }\r\n }\r\n\r\n /// @notice Grants roles to the specified addresses and defines admin roles\r\n /// @param roles The roles being granted\r\n /// @param members Addresses being granted each specified role\r\n function _grantRoles(string[] memory roles, address[][] memory members)\r\n internal\r\n {\r\n if (roles.length != members.length) revert UnequalArrayLengths();\r\n\r\n uint256 rolesLength = roles.length;\r\n for (uint256 i = 0; i < rolesLength; ) {\r\n uint256 membersLength = members[i].length;\r\n for (uint256 j = 0; j < membersLength; ) {\r\n _grantRole(roles[i], members[i][j]);\r\n unchecked {\r\n j++;\r\n }\r\n }\r\n unchecked {\r\n i++;\r\n }\r\n }\r\n }\r\n\r\n /// @notice Authorizes roles to execute the specified actions\r\n /// @param targets The contract addresses that the action functions are implemented on\r\n /// @param functionDescs The function descriptions used to define the actions\r\n /// @param roles Roles being granted permission for an action\r\n function _addActionsRoles(\r\n address[] memory targets,\r\n string[] memory functionDescs,\r\n string[][] memory roles\r\n ) internal {\r\n if (targets.length != functionDescs.length)\r\n revert UnequalArrayLengths();\r\n if (targets.length != roles.length) revert UnequalArrayLengths();\r\n\r\n uint256 targetsLength = targets.length;\r\n for (uint256 i = 0; i < targetsLength; ) {\r\n uint256 rolesLength = roles[i].length;\r\n for (uint256 j = 0; j < rolesLength; ) {\r\n _addActionRole(targets[i], functionDescs[i], roles[i][j]);\r\n unchecked {\r\n j++;\r\n }\r\n }\r\n unchecked {\r\n i++;\r\n }\r\n }\r\n }\r\n\r\n /// @notice Authorizes a role to execute the specified action\r\n /// @param target The contract address that the action function is implemented on\r\n /// @param functionDesc The function description used to define the action\r\n /// @param role Role being granted permission for an action\r\n function _addActionRole(\r\n address target,\r\n string memory functionDesc,\r\n string memory role\r\n ) internal {\r\n bytes4 encodedSig = bytes4(keccak256(abi.encodePacked(functionDesc)));\r\n _actionsToRoles[target][encodedSig].push(role);\r\n\r\n emit ActionRoleAdded(target, functionDesc, encodedSig, role);\r\n }\r\n\r\n /// @notice Removes authorization of a role to execute the specified action\r\n /// @param target The contract address that the action function is implemented on\r\n /// @param functionDesc The function description used to define the action\r\n /// @param role Role that the action authorization is being removed on\r\n function _removeActionRole(\r\n address target,\r\n string memory functionDesc,\r\n string memory role\r\n ) internal {\r\n bytes4 encodedSig = bytes4(keccak256(abi.encodePacked(functionDesc)));\r\n uint256 rolesLength = _actionsToRoles[target][encodedSig].length;\r\n for (uint256 i = 0; i < rolesLength; ) {\r\n if (\r\n keccak256(\r\n abi.encodePacked(_actionsToRoles[target][encodedSig][i])\r\n ) == keccak256(abi.encodePacked(role))\r\n ) {\r\n _actionsToRoles[target][encodedSig][i] = _actionsToRoles[\r\n target\r\n ][encodedSig][rolesLength - 1];\r\n _actionsToRoles[target][encodedSig].pop();\r\n\r\n emit ActionRoleRemoved(target, functionDesc, encodedSig, role);\r\n\r\n break;\r\n }\r\n unchecked {\r\n i++;\r\n }\r\n }\r\n }\r\n\r\n /// @notice Reverts when msg.sender is not authorized to upgrade the contract\r\n /// @notice Only addresses that have the DAO_ROLE role are authorized\r\n /// @notice Called by upgradeTo and upgradeToAndCall\r\n /// @param newImplementation New implementation contract address being upgraded to\r\n function _authorizeUpgrade(address newImplementation)\r\n internal\r\n override\r\n onlyRole(DAO_ROLE)\r\n {}\r\n\r\n /// @notice Reverts with a standard message if account is missing role\r\n /// @param role Role being checked\r\n /// @param account Address that role is being checked on\r\n function _checkRole(string memory role, address account) internal view {\r\n if (!hasRole(role, account)) {\r\n revert MissingRole(account, role);\r\n }\r\n }\r\n}\r\n" - }, - "@fractal-framework/core-contracts/contracts/DAO.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\nimport \"@openzeppelin/contracts/utils/Address.sol\";\r\n\r\nimport \"./interfaces/IDAO.sol\";\r\nimport \"./ModuleBase.sol\";\r\n\r\n/// @notice A minimum viable DAO contract\r\ncontract DAO is IDAO, ModuleBase {\r\n /// @notice Function for initializing the contract that can only be called once\r\n /// @param _accessControl The address of the access control contract\r\n /// @param _moduleFactory The address of the module factory\r\n /// @param _name Name of the Dao\r\n function initialize(address _accessControl, address _moduleFactory, string calldata _name) external initializer {\r\n __initBase(_accessControl, _moduleFactory, _name);\r\n _registerInterface(type(IDAO).interfaceId);\r\n }\r\n\r\n /// @notice A function for executing function calls from the DAO\r\n /// @param targets An array of addresses to target for the function calls\r\n /// @param values An array of ether values to send with the function calls\r\n /// @param calldatas An array of bytes defining the function calls\r\n function execute(\r\n address[] calldata targets,\r\n uint256[] calldata values,\r\n bytes[] calldata calldatas\r\n ) external authorized {\r\n if (\r\n targets.length != values.length ||\r\n targets.length != calldatas.length\r\n ) revert UnequalArrayLengths();\r\n string memory errorMessage = \"DAO: call reverted without message\";\r\n uint256 targetlength = targets.length;\r\n for (uint256 i = 0; i < targetlength; ) {\r\n (bool success, bytes memory returndata) = targets[i].call{\r\n value: values[i]\r\n }(calldatas[i]);\r\n Address.verifyCallResult(success, returndata, errorMessage);\r\n unchecked {\r\n i++;\r\n }\r\n }\r\n emit Executed(targets, values, calldatas);\r\n }\r\n}\r\n" - }, - "contracts/hardhat-dependency-compiler/@fractal-framework/core-contracts/contracts/DAO.sol": { - "content": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >0.0.0;\nimport '@fractal-framework/core-contracts/contracts/DAO.sol';\n" - }, - "contracts/hardhat-dependency-compiler/@fractal-framework/core-contracts/contracts/DAOAccessControl.sol": { - "content": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >0.0.0;\nimport '@fractal-framework/core-contracts/contracts/DAOAccessControl.sol';\n" - }, - "contracts/hardhat-dependency-compiler/@fractal-framework/core-contracts/contracts/DAOFactory.sol": { - "content": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >0.0.0;\nimport '@fractal-framework/core-contracts/contracts/DAOFactory.sol';\n" - } - }, - "settings": { - "optimizer": { - "enabled": true, - "runs": 200 - }, - "outputSelection": { - "*": { - "*": [ - "abi", - "evm.bytecode", - "evm.deployedBytecode", - "evm.methodIdentifiers", - "metadata", - "storageLayout", - "devdoc", - "userdoc", - "evm.gasEstimates" - ], - "": [ - "ast" - ] - } - }, - "metadata": { - "useLiteralContent": true - } - } -} \ No newline at end of file diff --git a/deployments/sepolia/.chainId b/deployments/sepolia/.chainId deleted file mode 100644 index bd8d1cd4..00000000 --- a/deployments/sepolia/.chainId +++ /dev/null @@ -1 +0,0 @@ -11155111 \ No newline at end of file diff --git a/deployments/sepolia/GnosisWrapper.json b/deployments/sepolia/GnosisWrapper.json deleted file mode 100644 index bf145f3f..00000000 --- a/deployments/sepolia/GnosisWrapper.json +++ /dev/null @@ -1,381 +0,0 @@ -{ - "address": "0xA5228ce81f86E0056b095B10ddABBa7758E5111E", - "abi": [ - { - "inputs": [], - "name": "NotAuthorized", - "type": "error" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": false, - "internalType": "address", - "name": "previousAdmin", - "type": "address" - }, - { - "indexed": false, - "internalType": "address", - "name": "newAdmin", - "type": "address" - } - ], - "name": "AdminChanged", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": true, - "internalType": "address", - "name": "beacon", - "type": "address" - } - ], - "name": "BeaconUpgraded", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": false, - "internalType": "uint8", - "name": "version", - "type": "uint8" - } - ], - "name": "Initialized", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": true, - "internalType": "address", - "name": "implementation", - "type": "address" - } - ], - "name": "Upgraded", - "type": "event" - }, - { - "inputs": [], - "name": "accessControl", - "outputs": [ - { - "internalType": "contract IDAOAccessControl", - "name": "", - "type": "address" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [], - "name": "gnosisSafe", - "outputs": [ - { - "internalType": "address", - "name": "", - "type": "address" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "_accessControl", - "type": "address" - }, - { - "internalType": "address", - "name": "_gnosisSafe", - "type": "address" - } - ], - "name": "initialize", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [], - "name": "moduleFactory", - "outputs": [ - { - "internalType": "address", - "name": "", - "type": "address" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [], - "name": "name", - "outputs": [ - { - "internalType": "string", - "name": "", - "type": "string" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [], - "name": "proxiableUUID", - "outputs": [ - { - "internalType": "bytes32", - "name": "", - "type": "bytes32" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "bytes4", - "name": "interfaceId", - "type": "bytes4" - } - ], - "name": "supportsInterface", - "outputs": [ - { - "internalType": "bool", - "name": "", - "type": "bool" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "newImplementation", - "type": "address" - } - ], - "name": "upgradeTo", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "newImplementation", - "type": "address" - }, - { - "internalType": "bytes", - "name": "data", - "type": "bytes" - } - ], - "name": "upgradeToAndCall", - "outputs": [], - "stateMutability": "payable", - "type": "function" - } - ], - "transactionHash": "0x326c8b3066824d366ab73ec6c041ea25dd9c2f9574ff05af4f995228ca2b277f", - "receipt": { - "to": null, - "from": "0x346658f99924B8Cfe8b6A2418070192385848CA9", - "contractAddress": "0xA5228ce81f86E0056b095B10ddABBa7758E5111E", - "transactionIndex": 6, - "gasUsed": "949574", - "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", - "blockHash": "0xec40dd60df2479e41e586f681f97f3abb31c20f668635b65f8342187edca23f4", - "transactionHash": "0x326c8b3066824d366ab73ec6c041ea25dd9c2f9574ff05af4f995228ca2b277f", - "logs": [], - "blockNumber": 1705151, - "cumulativeGasUsed": "1110818", - "status": 1, - "byzantium": true - }, - "args": [], - "numDeployments": 1, - "solcInputHash": "32801c180c72a260c0a67f69b3ec7a05", - "metadata": "{\"compiler\":{\"version\":\"0.8.13+commit.abaa5c0e\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"NotAuthorized\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"accessControl\",\"outputs\":[{\"internalType\":\"contract IDAOAccessControl\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"gnosisSafe\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_accessControl\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_gnosisSafe\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"moduleFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"name()\":{\"returns\":{\"_0\":\"The module name\"}},\"proxiableUUID()\":{\"details\":\"Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the implementation. It is used to validate that the this implementation remains valid after an upgrade. IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.\"},\"supportsInterface(bytes4)\":{\"details\":\"See {IERC165-supportsInterface}.\"},\"upgradeTo(address)\":{\"details\":\"Upgrade the implementation of the proxy to `newImplementation`. Calls {_authorizeUpgrade}. Emits an {Upgraded} event.\"},\"upgradeToAndCall(address,bytes)\":{\"details\":\"Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call encoded in `data`. Calls {_authorizeUpgrade}. Emits an {Upgraded} event.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"name()\":{\"notice\":\"Returns the module name\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/GnosisWrapper.sol\":\"GnosisWrapper\"},\"evmVersion\":\"london\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@fractal-framework/core-contracts/contracts/ModuleBase.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\\\";\\r\\nimport \\\"@openzeppelin/contracts/utils/introspection/ERC165Storage.sol\\\";\\r\\nimport \\\"./interfaces/IModuleBase.sol\\\";\\r\\n\\r\\n/// @notice An abstract contract to be inherited by module contracts\\r\\nabstract contract ModuleBase is IModuleBase, UUPSUpgradeable, ERC165Storage {\\r\\n IDAOAccessControl public accessControl;\\r\\n address public moduleFactory;\\r\\n string internal _name;\\r\\n\\r\\n /// @notice Requires that a function caller has the associated role\\r\\n modifier authorized() {\\r\\n if (\\r\\n !accessControl.actionIsAuthorized(\\r\\n msg.sender,\\r\\n address(this),\\r\\n msg.sig\\r\\n )\\r\\n ) {\\r\\n revert NotAuthorized();\\r\\n }\\r\\n _;\\r\\n }\\r\\n\\r\\n /// @notice Function for initializing the contract that can only be called once\\r\\n /// @param _accessControl The address of the access control contract\\r\\n /// @param _moduleFactory The address of the factory deploying the module\\r\\n /// @param __name Human readable string of the module name\\r\\n function __initBase(address _accessControl, address _moduleFactory, string memory __name)\\r\\n internal\\r\\n onlyInitializing\\r\\n {\\r\\n accessControl = IDAOAccessControl(_accessControl);\\r\\n moduleFactory = _moduleFactory;\\r\\n _name = __name;\\r\\n __UUPSUpgradeable_init();\\r\\n _registerInterface(type(IModuleBase).interfaceId);\\r\\n }\\r\\n\\r\\n /// @dev Applies authorized modifier so that an upgrade require the caller to have the correct role\\r\\n /// @param newImplementation The address of the new implementation contract being upgraded to\\r\\n function _authorizeUpgrade(address newImplementation)\\r\\n internal\\r\\n override\\r\\n authorized\\r\\n {}\\r\\n\\r\\n /// @notice Returns the module name\\r\\n /// @return The module name\\r\\n function name() public view virtual returns (string memory) {\\r\\n return _name;\\r\\n }\\r\\n}\\r\\n\",\"keccak256\":\"0xdd4b440c6924fe479e6e3c72e35d109c3af3a9eeb72eab85c65bbe31a2b05dcf\",\"license\":\"Unlicense\"},\"@fractal-framework/core-contracts/contracts/interfaces/IDAOAccessControl.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\ninterface IDAOAccessControl {\\r\\n struct RoleData {\\r\\n mapping(address => bool) members;\\r\\n string adminRole;\\r\\n }\\r\\n\\r\\n error UnequalArrayLengths();\\r\\n error MissingRole(address account, string role);\\r\\n error OnlySelfRenounce();\\r\\n\\r\\n event ActionRoleAdded(\\r\\n address target,\\r\\n string functionDesc,\\r\\n bytes4 encodedSig,\\r\\n string role\\r\\n );\\r\\n event ActionRoleRemoved(\\r\\n address target,\\r\\n string functionDesc,\\r\\n bytes4 encodedSig,\\r\\n string role\\r\\n );\\r\\n event RoleAdminChanged(\\r\\n string role,\\r\\n string previousAdminRole,\\r\\n string adminRole\\r\\n );\\r\\n event RoleGranted(string role, address account, address admin);\\r\\n event RoleRevoked(string role, address account, address admin);\\r\\n\\r\\n /// @notice Initialize DAO action and role permissions\\r\\n /// @param dao Address to receive DAO role\\r\\n /// @param roles What permissions are assigned to\\r\\n /// @param roleAdmins Roles which have the ability to remove or add members\\r\\n /// @param members Addresses to be granted the specified roles\\r\\n /// @param targets Contract addresses for actions to be defined on\\r\\n /// @param functionDescs Function descriptions used to define actions\\r\\n /// @param actionRoles Roles being granted permission for an action\\r\\n function initialize(\\r\\n address dao,\\r\\n string[] memory roles,\\r\\n string[] memory roleAdmins,\\r\\n address[][] memory members,\\r\\n address[] memory targets,\\r\\n string[] memory functionDescs,\\r\\n string[][] memory actionRoles\\r\\n ) external;\\r\\n\\r\\n /// @notice Grants roles to the specified addresses and defines admin roles\\r\\n /// @notice This function can only be called by the DAO\\r\\n /// @param roles The roles being granted\\r\\n /// @param roleAdmins The roles being granted as admins of the specified of roles\\r\\n /// @param members Addresses being granted each specified role\\r\\n function daoGrantRolesAndAdmins(\\r\\n string[] memory roles,\\r\\n string[] memory roleAdmins,\\r\\n address[][] memory members\\r\\n ) external;\\r\\n\\r\\n /// @notice Grants roles to the specified addresses\\r\\n /// @notice This function can only be called by the DAO\\r\\n /// @param roles The roles being granted\\r\\n /// @param members Addresses being granted each specified role\\r\\n function daoGrantRoles(string[] memory roles, address[][] memory members)\\r\\n external;\\r\\n\\r\\n /// @notice Authorizes roles to execute the specified actions\\r\\n /// @notice This function can only be called by the DAO\\r\\n /// @param targets The contract addresses that the action functions are implemented on\\r\\n /// @param functionDescs The function descriptions used to define the actions\\r\\n /// @param roles Roles being granted permission for an action\\r\\n function daoAddActionsRoles(\\r\\n address[] memory targets,\\r\\n string[] memory functionDescs,\\r\\n string[][] memory roles\\r\\n ) external;\\r\\n\\r\\n /// @notice Removes autorization for roles to execute the specified actions\\r\\n /// @notice This function can only be called by the DAO\\r\\n /// @param targets The contract addresses that the action functions are implemented on\\r\\n /// @param functionDescs The function description used to define the actions\\r\\n /// @param roles Roles that action permissions are being removed on\\r\\n function daoRemoveActionsRoles(\\r\\n address[] memory targets,\\r\\n string[] memory functionDescs,\\r\\n string[][] memory roles\\r\\n ) external;\\r\\n\\r\\n /// @notice Grants a role to the specified address\\r\\n /// @notice This function can only be called by an admin of the specified role\\r\\n /// @param role The role being granted\\r\\n /// @param account The address being granted the specified role\\r\\n function adminGrantRole(string memory role, address account)\\r\\n external;\\r\\n\\r\\n /// @notice Revokes a role from the specified address\\r\\n /// @notice This function can only be called by an admin of the specified role\\r\\n /// @param role The role being revoked\\r\\n /// @param account The address the role is being revoked from\\r\\n function adminRevokeRole(string memory role, address account)\\r\\n external;\\r\\n\\r\\n /// @notice Enables an address to remove one of its own roles\\r\\n /// @notice This function can only be called by the account specified\\r\\n /// @param role The role being renounced\\r\\n /// @param account The address renouncing the role\\r\\n function userRenounceRole(string memory role, address account) external;\\r\\n\\r\\n /// @notice Checks if a caller has the permissions to execute the specific action\\r\\n /// @param caller Address attempting to execute the action\\r\\n /// @param target Contract address corresponding to the action\\r\\n /// @param sig The function signature used to define the action\\r\\n function actionIsAuthorized(\\r\\n address caller,\\r\\n address target,\\r\\n bytes4 sig\\r\\n ) external view returns (bool isAuthorized);\\r\\n\\r\\n /// @notice Returns the roles autorized to execute the specified action\\r\\n /// @param target Contract address corresponding to the action\\r\\n /// @param functionDesc The function description used to define the action\\r\\n function getActionRoles(address target, string memory functionDesc)\\r\\n external\\r\\n view\\r\\n returns (string[] memory roles);\\r\\n\\r\\n /// @notice Checks if a specific role is authorized for an action\\r\\n /// @param role Role that authorization is being checked on\\r\\n /// @param target Contract address corresponding to the action\\r\\n /// @param functionDesc Function description used to define the action\\r\\n /// @return isAuthorized Indicates whether the role is authorized to execute the action\\r\\n function isRoleAuthorized(\\r\\n string calldata role,\\r\\n address target,\\r\\n string memory functionDesc\\r\\n ) external view returns (bool isAuthorized);\\r\\n\\r\\n /// @notice Returns whether the account has been granted the role\\r\\n /// @param role Role that authorization is being checked on\\r\\n /// @param account Address that the role authorization is being check on\\r\\n /// @return boolean Indicates whether the address has been granted the role\\r\\n function hasRole(string memory role, address account)\\r\\n external\\r\\n view\\r\\n returns (bool);\\r\\n\\r\\n /// @notice Returns the role that is the admin of the specified role\\r\\n /// @param role Role that the admin role is being returned for\\r\\n /// @return string The admin role of the specified role\\r\\n function getRoleAdmin(string memory role)\\r\\n external\\r\\n view\\r\\n returns (string memory);\\r\\n\\r\\n /// @return string The string \\\"DAO_ROLE\\\"\\r\\n function DAO_ROLE() external view returns (string memory);\\r\\n}\\r\\n\",\"keccak256\":\"0x8862f578b4fe6a79370b5cbe896e59df4722e95dbb1b0d2e286e335915ed616c\",\"license\":\"Unlicense\"},\"@fractal-framework/core-contracts/contracts/interfaces/IModuleBase.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\nimport \\\"./IDAOAccessControl.sol\\\";\\r\\n\\r\\ninterface IModuleBase {\\r\\n error NotAuthorized();\\r\\n\\r\\n /// @return IDAOAccessControl The Access control interface\\r\\n function accessControl() external view returns (IDAOAccessControl);\\r\\n\\r\\n /// @return string The string \\\"Name\\\"\\r\\n function name() external view returns (string memory);\\r\\n}\\r\\n\",\"keccak256\":\"0xf7aa0a6fc64e3ea68e1fe799390408e62bfd9d1339d6c31c6d862f3af158cca6\",\"license\":\"Unlicense\"},\"@openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified\\n * proxy whose upgrades are fully controlled by the current implementation.\\n */\\ninterface IERC1822ProxiableUpgradeable {\\n /**\\n * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation\\n * address.\\n *\\n * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\\n * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\\n * function revert if invoked through a proxy.\\n */\\n function proxiableUUID() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0x77c89f893e403efc6929ba842b7ccf6534d4ffe03afe31670b4a528c0ad78c0f\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/ERC1967/ERC1967UpgradeUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../beacon/IBeaconUpgradeable.sol\\\";\\nimport \\\"../../interfaces/draft-IERC1822Upgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/StorageSlotUpgradeable.sol\\\";\\nimport \\\"../utils/Initializable.sol\\\";\\n\\n/**\\n * @dev This abstract contract provides getters and event emitting update functions for\\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.\\n *\\n * _Available since v4.1._\\n *\\n * @custom:oz-upgrades-unsafe-allow delegatecall\\n */\\nabstract contract ERC1967UpgradeUpgradeable is Initializable {\\n function __ERC1967Upgrade_init() internal onlyInitializing {\\n }\\n\\n function __ERC1967Upgrade_init_unchained() internal onlyInitializing {\\n }\\n // This is the keccak-256 hash of \\\"eip1967.proxy.rollback\\\" subtracted by 1\\n bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;\\n\\n /**\\n * @dev Storage slot with the address of the current implementation.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.implementation\\\" subtracted by 1, and is\\n * validated in the constructor.\\n */\\n bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n /**\\n * @dev Emitted when the implementation is upgraded.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function _getImplementation() internal view returns (address) {\\n return StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new address in the EIP1967 implementation slot.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(AddressUpgradeable.isContract(newImplementation), \\\"ERC1967: new implementation is not a contract\\\");\\n StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\\n }\\n\\n /**\\n * @dev Perform implementation upgrade\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeTo(address newImplementation) internal {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Perform implementation upgrade with additional setup call.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeToAndCall(\\n address newImplementation,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n _upgradeTo(newImplementation);\\n if (data.length > 0 || forceCall) {\\n _functionDelegateCall(newImplementation, data);\\n }\\n }\\n\\n /**\\n * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeToAndCallUUPS(\\n address newImplementation,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n // Upgrades from old implementations will perform a rollback test. This test requires the new\\n // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing\\n // this special case will break upgrade paths from old UUPS implementation to new ones.\\n if (StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT).value) {\\n _setImplementation(newImplementation);\\n } else {\\n try IERC1822ProxiableUpgradeable(newImplementation).proxiableUUID() returns (bytes32 slot) {\\n require(slot == _IMPLEMENTATION_SLOT, \\\"ERC1967Upgrade: unsupported proxiableUUID\\\");\\n } catch {\\n revert(\\\"ERC1967Upgrade: new implementation is not UUPS\\\");\\n }\\n _upgradeToAndCall(newImplementation, data, forceCall);\\n }\\n }\\n\\n /**\\n * @dev Storage slot with the admin of the contract.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.admin\\\" subtracted by 1, and is\\n * validated in the constructor.\\n */\\n bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\\n\\n /**\\n * @dev Emitted when the admin account has changed.\\n */\\n event AdminChanged(address previousAdmin, address newAdmin);\\n\\n /**\\n * @dev Returns the current admin.\\n */\\n function _getAdmin() internal view returns (address) {\\n return StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new address in the EIP1967 admin slot.\\n */\\n function _setAdmin(address newAdmin) private {\\n require(newAdmin != address(0), \\\"ERC1967: new admin is the zero address\\\");\\n StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value = newAdmin;\\n }\\n\\n /**\\n * @dev Changes the admin of the proxy.\\n *\\n * Emits an {AdminChanged} event.\\n */\\n function _changeAdmin(address newAdmin) internal {\\n emit AdminChanged(_getAdmin(), newAdmin);\\n _setAdmin(newAdmin);\\n }\\n\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Emitted when the beacon is upgraded.\\n */\\n event BeaconUpgraded(address indexed beacon);\\n\\n /**\\n * @dev Returns the current beacon.\\n */\\n function _getBeacon() internal view returns (address) {\\n return StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new beacon in the EIP1967 beacon slot.\\n */\\n function _setBeacon(address newBeacon) private {\\n require(AddressUpgradeable.isContract(newBeacon), \\\"ERC1967: new beacon is not a contract\\\");\\n require(\\n AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()),\\n \\\"ERC1967: beacon implementation is not a contract\\\"\\n );\\n StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value = newBeacon;\\n }\\n\\n /**\\n * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does\\n * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).\\n *\\n * Emits a {BeaconUpgraded} event.\\n */\\n function _upgradeBeaconToAndCall(\\n address newBeacon,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n _setBeacon(newBeacon);\\n emit BeaconUpgraded(newBeacon);\\n if (data.length > 0 || forceCall) {\\n _functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data);\\n }\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function _functionDelegateCall(address target, bytes memory data) private returns (bytes memory) {\\n require(AddressUpgradeable.isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return AddressUpgradeable.verifyCallResult(success, returndata, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x315887e846f1e5f8d8fa535a229d318bb9290aaa69485117f1ee8a9a6b3be823\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/beacon/IBeaconUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeaconUpgradeable {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x24b86ac8c005b8c654fbf6ac34a5a4f61580d7273541e83e013e89d66fbf0908\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\\n * reused. This mechanism prevents re-execution of each \\\"step\\\" but allows the creation of new initialization steps in\\n * case an upgrade adds a module that needs to be initialized.\\n *\\n * For example:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * contract MyToken is ERC20Upgradeable {\\n * function initialize() initializer public {\\n * __ERC20_init(\\\"MyToken\\\", \\\"MTK\\\");\\n * }\\n * }\\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\\n * function initializeV2() reinitializer(2) public {\\n * __ERC20Permit_init(\\\"MyToken\\\");\\n * }\\n * }\\n * ```\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n *\\n * [CAUTION]\\n * ====\\n * Avoid leaving a contract uninitialized.\\n *\\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * /// @custom:oz-upgrades-unsafe-allow constructor\\n * constructor() {\\n * _disableInitializers();\\n * }\\n * ```\\n * ====\\n */\\nabstract contract Initializable {\\n /**\\n * @dev Indicates that the contract has been initialized.\\n * @custom:oz-retyped-from bool\\n */\\n uint8 private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Triggered when the contract has been initialized or reinitialized.\\n */\\n event Initialized(uint8 version);\\n\\n /**\\n * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\\n * `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`.\\n */\\n modifier initializer() {\\n bool isTopLevelCall = !_initializing;\\n require(\\n (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\\n \\\"Initializable: contract is already initialized\\\"\\n );\\n _initialized = 1;\\n if (isTopLevelCall) {\\n _initializing = true;\\n }\\n _;\\n if (isTopLevelCall) {\\n _initializing = false;\\n emit Initialized(1);\\n }\\n }\\n\\n /**\\n * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\\n * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\\n * used to initialize parent contracts.\\n *\\n * `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original\\n * initialization step. This is essential to configure modules that are added through upgrades and that require\\n * initialization.\\n *\\n * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\\n * a contract, executing them in the right order is up to the developer or operator.\\n */\\n modifier reinitializer(uint8 version) {\\n require(!_initializing && _initialized < version, \\\"Initializable: contract is already initialized\\\");\\n _initialized = version;\\n _initializing = true;\\n _;\\n _initializing = false;\\n emit Initialized(version);\\n }\\n\\n /**\\n * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\\n * {initializer} and {reinitializer} modifiers, directly or indirectly.\\n */\\n modifier onlyInitializing() {\\n require(_initializing, \\\"Initializable: contract is not initializing\\\");\\n _;\\n }\\n\\n /**\\n * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\\n * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\\n * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\\n * through proxies.\\n */\\n function _disableInitializers() internal virtual {\\n require(!_initializing, \\\"Initializable: contract is initializing\\\");\\n if (_initialized < type(uint8).max) {\\n _initialized = type(uint8).max;\\n emit Initialized(type(uint8).max);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0203dcadc5737d9ef2c211d6fa15d18ebc3b30dfa51903b64870b01a062b0b4e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (proxy/utils/UUPSUpgradeable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../interfaces/draft-IERC1822Upgradeable.sol\\\";\\nimport \\\"../ERC1967/ERC1967UpgradeUpgradeable.sol\\\";\\nimport \\\"./Initializable.sol\\\";\\n\\n/**\\n * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an\\n * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.\\n *\\n * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is\\n * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing\\n * `UUPSUpgradeable` with a custom implementation of upgrades.\\n *\\n * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.\\n *\\n * _Available since v4.1._\\n */\\nabstract contract UUPSUpgradeable is Initializable, IERC1822ProxiableUpgradeable, ERC1967UpgradeUpgradeable {\\n function __UUPSUpgradeable_init() internal onlyInitializing {\\n }\\n\\n function __UUPSUpgradeable_init_unchained() internal onlyInitializing {\\n }\\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment\\n address private immutable __self = address(this);\\n\\n /**\\n * @dev Check that the execution is being performed through a delegatecall call and that the execution context is\\n * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case\\n * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a\\n * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to\\n * fail.\\n */\\n modifier onlyProxy() {\\n require(address(this) != __self, \\\"Function must be called through delegatecall\\\");\\n require(_getImplementation() == __self, \\\"Function must be called through active proxy\\\");\\n _;\\n }\\n\\n /**\\n * @dev Check that the execution is not being performed through a delegate call. This allows a function to be\\n * callable on the implementing contract but not through proxies.\\n */\\n modifier notDelegated() {\\n require(address(this) == __self, \\\"UUPSUpgradeable: must not be called through delegatecall\\\");\\n _;\\n }\\n\\n /**\\n * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the\\n * implementation. It is used to validate that the this implementation remains valid after an upgrade.\\n *\\n * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\\n * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\\n * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.\\n */\\n function proxiableUUID() external view virtual override notDelegated returns (bytes32) {\\n return _IMPLEMENTATION_SLOT;\\n }\\n\\n /**\\n * @dev Upgrade the implementation of the proxy to `newImplementation`.\\n *\\n * Calls {_authorizeUpgrade}.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function upgradeTo(address newImplementation) external virtual onlyProxy {\\n _authorizeUpgrade(newImplementation);\\n _upgradeToAndCallUUPS(newImplementation, new bytes(0), false);\\n }\\n\\n /**\\n * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call\\n * encoded in `data`.\\n *\\n * Calls {_authorizeUpgrade}.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function upgradeToAndCall(address newImplementation, bytes memory data) external payable virtual onlyProxy {\\n _authorizeUpgrade(newImplementation);\\n _upgradeToAndCallUUPS(newImplementation, data, true);\\n }\\n\\n /**\\n * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by\\n * {upgradeTo} and {upgradeToAndCall}.\\n *\\n * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.\\n *\\n * ```solidity\\n * function _authorizeUpgrade(address) internal override onlyOwner {}\\n * ```\\n */\\n function _authorizeUpgrade(address newImplementation) internal virtual;\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x6e36e9b4b71de699c2f3f0d4e4d1aa0b35da99a26e8d5b91ef09ba234b4ef270\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x611aa3f23e59cfdd1863c536776407b3e33d695152a266fa7cfb34440a29a8a3\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StorageSlotUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for reading and writing primitive types to specific storage slots.\\n *\\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\\n * This library helps with reading and writing to such slots without the need for inline assembly.\\n *\\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\\n *\\n * Example usage to set ERC1967 implementation slot:\\n * ```\\n * contract ERC1967 {\\n * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n *\\n * function _getImplementation() internal view returns (address) {\\n * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\\n * }\\n *\\n * function _setImplementation(address newImplementation) internal {\\n * require(Address.isContract(newImplementation), \\\"ERC1967: new implementation is not a contract\\\");\\n * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\\n * }\\n * }\\n * ```\\n *\\n * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._\\n */\\nlibrary StorageSlotUpgradeable {\\n struct AddressSlot {\\n address value;\\n }\\n\\n struct BooleanSlot {\\n bool value;\\n }\\n\\n struct Bytes32Slot {\\n bytes32 value;\\n }\\n\\n struct Uint256Slot {\\n uint256 value;\\n }\\n\\n /**\\n * @dev Returns an `AddressSlot` with member `value` located at `slot`.\\n */\\n function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\\n */\\n function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\\n */\\n function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\\n */\\n function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n}\\n\",\"keccak256\":\"0x09864aea84f01e39313375b5610c73a3c1c68abbdc51e5ccdd25ff977fdadf9a\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/ERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165 is IERC165 {\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165).interfaceId;\\n }\\n}\\n\",\"keccak256\":\"0xd10975de010d89fd1c78dc5e8a9a7e7f496198085c151648f20cba166b32582b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/ERC165Storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165Storage.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./ERC165.sol\\\";\\n\\n/**\\n * @dev Storage based implementation of the {IERC165} interface.\\n *\\n * Contracts may inherit from this and call {_registerInterface} to declare\\n * their support of an interface.\\n */\\nabstract contract ERC165Storage is ERC165 {\\n /**\\n * @dev Mapping of interface ids to whether or not it's supported.\\n */\\n mapping(bytes4 => bool) private _supportedInterfaces;\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return super.supportsInterface(interfaceId) || _supportedInterfaces[interfaceId];\\n }\\n\\n /**\\n * @dev Registers the contract as an implementer of the interface defined by\\n * `interfaceId`. Support of the actual ERC165 interface is automatic and\\n * registering its interface id is not required.\\n *\\n * See {IERC165-supportsInterface}.\\n *\\n * Requirements:\\n *\\n * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).\\n */\\n function _registerInterface(bytes4 interfaceId) internal virtual {\\n require(interfaceId != 0xffffffff, \\\"ERC165: invalid interface id\\\");\\n _supportedInterfaces[interfaceId] = true;\\n }\\n}\\n\",\"keccak256\":\"0x77bf0086774bab931413c3388d3a0f7d44cf6878965b72147f57bb0fbbf394bd\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x447a5f3ddc18419d41ff92b3773fb86471b1db25773e07f877f548918a185bf1\",\"license\":\"MIT\"},\"contracts/GnosisWrapper.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\nimport \\\"@fractal-framework/core-contracts/contracts/ModuleBase.sol\\\";\\r\\nimport \\\"./IGnosisWrapper.sol\\\";\\r\\n\\r\\ncontract GnosisWrapper is ModuleBase {\\r\\n address public gnosisSafe;\\r\\n\\r\\n function initialize(address _accessControl, address _gnosisSafe)\\r\\n public\\r\\n initializer\\r\\n {\\r\\n __initBase(_accessControl, msg.sender, \\\"Wrapper Module\\\");\\r\\n _registerInterface(type(IGnosisWrapper).interfaceId);\\r\\n gnosisSafe = _gnosisSafe;\\r\\n }\\r\\n}\\r\\n\",\"keccak256\":\"0xd2641d9481951a753eea302e81b64ccdf06799b852b166761dcb50ac0f076131\",\"license\":\"Unlicense\"},\"contracts/IGnosisWrapper.sol\":{\"content\":\"pragma solidity ^0.8.0;\\r\\n\\r\\ninterface IGnosisWrapper {\\r\\n function initialize(address _accessControl, address _gnosisSafe) external;\\r\\n function gnosisSafe() external view returns(address);\\r\\n}\\r\\n\",\"keccak256\":\"0xff67355c4beff15b94229e0d77aea18a7a2631b0c3590fe03b3abeaf8d833ac3\"}},\"version\":1}", - "bytecode": "0x60a06040523060805234801561001457600080fd5b5060805161103c61004c600039600081816102ae015281816102f7015281816104fd0152818161053d01526105d0015261103c6000f3fe6080604052600436106100865760003560e01c8063485cc95511610059578063485cc9551461013c5780634f1ef2861461015c57806352d1902d1461016f5780638991255b14610192578063a84173ae146101b257600080fd5b806301ffc9a71461008b57806306fdde03146100c057806313007d55146100e25780633659cfe61461011a575b600080fd5b34801561009757600080fd5b506100ab6100a6366004610c80565b6101d2565b60405190151581526020015b60405180910390f35b3480156100cc57600080fd5b506100d5610212565b6040516100b79190610cd6565b3480156100ee57600080fd5b50606654610102906001600160a01b031681565b6040516001600160a01b0390911681526020016100b7565b34801561012657600080fd5b5061013a610135366004610d25565b6102a4565b005b34801561014857600080fd5b5061013a610157366004610d40565b61038c565b61013a61016a366004610d89565b6104f3565b34801561017b57600080fd5b506101846105c3565b6040519081526020016100b7565b34801561019e57600080fd5b50606754610102906001600160a01b031681565b3480156101be57600080fd5b50606954610102906001600160a01b031681565b60006301ffc9a760e01b6001600160e01b03198316148061020c57506001600160e01b0319821660009081526065602052604090205460ff165b92915050565b60606068805461022190610e4b565b80601f016020809104026020016040519081016040528092919081815260200182805461024d90610e4b565b801561029a5780601f1061026f5761010080835404028352916020019161029a565b820191906000526020600020905b81548152906001019060200180831161027d57829003601f168201915b5050505050905090565b6001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001630036102f55760405162461bcd60e51b81526004016102ec90610e85565b60405180910390fd5b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031661033e600080516020610fc0833981519152546001600160a01b031690565b6001600160a01b0316146103645760405162461bcd60e51b81526004016102ec90610ed1565b61036d81610676565b604080516000808252602082019092526103899183919061071a565b50565b600054610100900460ff16158080156103ac5750600054600160ff909116105b806103c65750303b1580156103c6575060005460ff166001145b6104295760405162461bcd60e51b815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201526d191e481a5b9a5d1a585b1a5e995960921b60648201526084016102ec565b6000805460ff19166001179055801561044c576000805461ff0019166101001790555b61047d83336040518060400160405280600e81526020016d57726170706572204d6f64756c6560901b815250610885565b61048d63e01dbafb60e01b610904565b606980546001600160a01b0319166001600160a01b03841617905580156104ee576000805461ff0019169055604051600181527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a15b505050565b6001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016300361053b5760405162461bcd60e51b81526004016102ec90610e85565b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316610584600080516020610fc0833981519152546001600160a01b031690565b6001600160a01b0316146105aa5760405162461bcd60e51b81526004016102ec90610ed1565b6105b382610676565b6105bf8282600161071a565b5050565b6000306001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016146106635760405162461bcd60e51b815260206004820152603860248201527f555550535570677261646561626c653a206d757374206e6f742062652063616c60448201527f6c6564207468726f7567682064656c656761746563616c6c000000000000000060648201526084016102ec565b50600080516020610fc083398151915290565b6066546040516001623b410b60e21b031981523360048201523060248201526000356001600160e01b03191660448201526001600160a01b039091169063ff12fbd490606401602060405180830381865afa1580156106d9573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906106fd9190610f1d565b6103895760405163ea8e4eb560e01b815260040160405180910390fd5b7f4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd91435460ff161561074d576104ee83610983565b826001600160a01b03166352d1902d6040518163ffffffff1660e01b8152600401602060405180830381865afa9250505080156107a7575060408051601f3d908101601f191682019092526107a491810190610f3f565b60015b61080a5760405162461bcd60e51b815260206004820152602e60248201527f45524331393637557067726164653a206e657720696d706c656d656e7461746960448201526d6f6e206973206e6f74205555505360901b60648201526084016102ec565b600080516020610fc083398151915281146108795760405162461bcd60e51b815260206004820152602960248201527f45524331393637557067726164653a20756e737570706f727465642070726f786044820152681a58589b195555525160ba1b60648201526084016102ec565b506104ee838383610a1f565b600054610100900460ff166108ac5760405162461bcd60e51b81526004016102ec90610f58565b606680546001600160a01b038086166001600160a01b031992831617909255606780549285169290911691909117905580516108ef906068906020840190610be7565b506108f8610a4a565b6104ee630afed1ab60e11b5b6001600160e01b0319808216900361095e5760405162461bcd60e51b815260206004820152601c60248201527f4552433136353a20696e76616c696420696e746572666163652069640000000060448201526064016102ec565b6001600160e01b0319166000908152606560205260409020805460ff19166001179055565b6001600160a01b0381163b6109f05760405162461bcd60e51b815260206004820152602d60248201527f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60448201526c1bdd08184818dbdb9d1c9858dd609a1b60648201526084016102ec565b600080516020610fc083398151915280546001600160a01b0319166001600160a01b0392909216919091179055565b610a2883610a73565b600082511180610a355750805b156104ee57610a448383610ab3565b50505050565b600054610100900460ff16610a715760405162461bcd60e51b81526004016102ec90610f58565b565b610a7c81610983565b6040516001600160a01b038216907fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b90600090a250565b60606001600160a01b0383163b610b1b5760405162461bcd60e51b815260206004820152602660248201527f416464726573733a2064656c65676174652063616c6c20746f206e6f6e2d636f6044820152651b9d1c9858dd60d21b60648201526084016102ec565b600080846001600160a01b031684604051610b369190610fa3565b600060405180830381855af49150503d8060008114610b71576040519150601f19603f3d011682016040523d82523d6000602084013e610b76565b606091505b5091509150610b9e8282604051806060016040528060278152602001610fe060279139610ba7565b95945050505050565b60608315610bb6575081610be0565b825115610bc65782518084602001fd5b8160405162461bcd60e51b81526004016102ec9190610cd6565b9392505050565b828054610bf390610e4b565b90600052602060002090601f016020900481019282610c155760008555610c5b565b82601f10610c2e57805160ff1916838001178555610c5b565b82800160010185558215610c5b579182015b82811115610c5b578251825591602001919060010190610c40565b50610c67929150610c6b565b5090565b5b80821115610c675760008155600101610c6c565b600060208284031215610c9257600080fd5b81356001600160e01b031981168114610be057600080fd5b60005b83811015610cc5578181015183820152602001610cad565b83811115610a445750506000910152565b6020815260008251806020840152610cf5816040850160208701610caa565b601f01601f19169190910160400192915050565b80356001600160a01b0381168114610d2057600080fd5b919050565b600060208284031215610d3757600080fd5b610be082610d09565b60008060408385031215610d5357600080fd5b610d5c83610d09565b9150610d6a60208401610d09565b90509250929050565b634e487b7160e01b600052604160045260246000fd5b60008060408385031215610d9c57600080fd5b610da583610d09565b9150602083013567ffffffffffffffff80821115610dc257600080fd5b818501915085601f830112610dd657600080fd5b813581811115610de857610de8610d73565b604051601f8201601f19908116603f01168101908382118183101715610e1057610e10610d73565b81604052828152886020848701011115610e2957600080fd5b8260208601602083013760006020848301015280955050505050509250929050565b600181811c90821680610e5f57607f821691505b602082108103610e7f57634e487b7160e01b600052602260045260246000fd5b50919050565b6020808252602c908201527f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060408201526b19195b1959d85d1958d85b1b60a21b606082015260800190565b6020808252602c908201527f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060408201526b6163746976652070726f787960a01b606082015260800190565b600060208284031215610f2f57600080fd5b81518015158114610be057600080fd5b600060208284031215610f5157600080fd5b5051919050565b6020808252602b908201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960408201526a6e697469616c697a696e6760a81b606082015260800190565b60008251610fb5818460208701610caa565b919091019291505056fe360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a264697066735822122058b7339af06bfa3bb8a1fcf63a3f890493b9514af9a88e0d3c011d687e8c9b1264736f6c634300080d0033", - "deployedBytecode": "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", - "devdoc": { - "kind": "dev", - "methods": { - "name()": { - "returns": { - "_0": "The module name" - } - }, - "proxiableUUID()": { - "details": "Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the implementation. It is used to validate that the this implementation remains valid after an upgrade. IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier." - }, - "supportsInterface(bytes4)": { - "details": "See {IERC165-supportsInterface}." - }, - "upgradeTo(address)": { - "details": "Upgrade the implementation of the proxy to `newImplementation`. Calls {_authorizeUpgrade}. Emits an {Upgraded} event." - }, - "upgradeToAndCall(address,bytes)": { - "details": "Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call encoded in `data`. Calls {_authorizeUpgrade}. Emits an {Upgraded} event." - } - }, - "version": 1 - }, - "userdoc": { - "kind": "user", - "methods": { - "name()": { - "notice": "Returns the module name" - } - }, - "version": 1 - }, - "storageLayout": { - "storage": [ - { - "astId": 2427, - "contract": "contracts/GnosisWrapper.sol:GnosisWrapper", - "label": "_initialized", - "offset": 0, - "slot": "0", - "type": "t_uint8" - }, - { - "astId": 2430, - "contract": "contracts/GnosisWrapper.sol:GnosisWrapper", - "label": "_initializing", - "offset": 1, - "slot": "0", - "type": "t_bool" - }, - { - "astId": 2409, - "contract": "contracts/GnosisWrapper.sol:GnosisWrapper", - "label": "__gap", - "offset": 0, - "slot": "1", - "type": "t_array(t_uint256)50_storage" - }, - { - "astId": 2706, - "contract": "contracts/GnosisWrapper.sol:GnosisWrapper", - "label": "__gap", - "offset": 0, - "slot": "51", - "type": "t_array(t_uint256)50_storage" - }, - { - "astId": 4073, - "contract": "contracts/GnosisWrapper.sol:GnosisWrapper", - "label": "_supportedInterfaces", - "offset": 0, - "slot": "101", - "type": "t_mapping(t_bytes4,t_bool)" - }, - { - "astId": 1411, - "contract": "contracts/GnosisWrapper.sol:GnosisWrapper", - "label": "accessControl", - "offset": 0, - "slot": "102", - "type": "t_contract(IDAOAccessControl)1841" - }, - { - "astId": 1413, - "contract": "contracts/GnosisWrapper.sol:GnosisWrapper", - "label": "moduleFactory", - "offset": 0, - "slot": "103", - "type": "t_address" - }, - { - "astId": 1415, - "contract": "contracts/GnosisWrapper.sol:GnosisWrapper", - "label": "_name", - "offset": 0, - "slot": "104", - "type": "t_string_storage" - }, - { - "astId": 4133, - "contract": "contracts/GnosisWrapper.sol:GnosisWrapper", - "label": "gnosisSafe", - "offset": 0, - "slot": "105", - "type": "t_address" - } - ], - "types": { - "t_address": { - "encoding": "inplace", - "label": "address", - "numberOfBytes": "20" - }, - "t_array(t_uint256)50_storage": { - "base": "t_uint256", - "encoding": "inplace", - "label": "uint256[50]", - "numberOfBytes": "1600" - }, - "t_bool": { - "encoding": "inplace", - "label": "bool", - "numberOfBytes": "1" - }, - "t_bytes4": { - "encoding": "inplace", - "label": "bytes4", - "numberOfBytes": "4" - }, - "t_contract(IDAOAccessControl)1841": { - "encoding": "inplace", - "label": "contract IDAOAccessControl", - "numberOfBytes": "20" - }, - "t_mapping(t_bytes4,t_bool)": { - "encoding": "mapping", - "key": "t_bytes4", - "label": "mapping(bytes4 => bool)", - "numberOfBytes": "32", - "value": "t_bool" - }, - "t_string_storage": { - "encoding": "bytes", - "label": "string", - "numberOfBytes": "32" - }, - "t_uint256": { - "encoding": "inplace", - "label": "uint256", - "numberOfBytes": "32" - }, - "t_uint8": { - "encoding": "inplace", - "label": "uint8", - "numberOfBytes": "1" - } - } - } -} \ No newline at end of file diff --git a/deployments/sepolia/GnosisWrapperFactory.json b/deployments/sepolia/GnosisWrapperFactory.json deleted file mode 100644 index b5255a1e..00000000 --- a/deployments/sepolia/GnosisWrapperFactory.json +++ /dev/null @@ -1,404 +0,0 @@ -{ - "address": "0x72Dc614736Fd5A3cCc805e654530F7229710c8e3", - "abi": [ - { - "anonymous": false, - "inputs": [ - { - "indexed": false, - "internalType": "address", - "name": "gnosisSafe", - "type": "address" - } - ], - "name": "GnosisWrapperCreated", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": false, - "internalType": "uint8", - "name": "version", - "type": "uint8" - } - ], - "name": "Initialized", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": true, - "internalType": "address", - "name": "previousOwner", - "type": "address" - }, - { - "indexed": true, - "internalType": "address", - "name": "newOwner", - "type": "address" - } - ], - "name": "OwnershipTransferred", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": false, - "internalType": "string", - "name": "semanticVersion", - "type": "string" - }, - { - "indexed": false, - "internalType": "string", - "name": "frontendURI", - "type": "string" - }, - { - "indexed": false, - "internalType": "address", - "name": "impl", - "type": "address" - } - ], - "name": "VersionCreated", - "type": "event" - }, - { - "inputs": [ - { - "internalType": "string", - "name": "_semanticVersion", - "type": "string" - }, - { - "internalType": "string", - "name": "_frontendURI", - "type": "string" - }, - { - "internalType": "address", - "name": "_impl", - "type": "address" - } - ], - "name": "addVersion", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "creator", - "type": "address" - }, - { - "internalType": "bytes[]", - "name": "data", - "type": "bytes[]" - } - ], - "name": "create", - "outputs": [ - { - "internalType": "address[]", - "name": "", - "type": "address[]" - } - ], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [], - "name": "initialize", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [], - "name": "owner", - "outputs": [ - { - "internalType": "address", - "name": "", - "type": "address" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [], - "name": "renounceOwnership", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "bytes4", - "name": "interfaceId", - "type": "bytes4" - } - ], - "name": "supportsInterface", - "outputs": [ - { - "internalType": "bool", - "name": "", - "type": "bool" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "address", - "name": "newOwner", - "type": "address" - } - ], - "name": "transferOwnership", - "outputs": [], - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { - "internalType": "uint256", - "name": "", - "type": "uint256" - } - ], - "name": "versionControl", - "outputs": [ - { - "internalType": "string", - "name": "semanticVersion", - "type": "string" - }, - { - "internalType": "string", - "name": "frontendURI", - "type": "string" - }, - { - "internalType": "address", - "name": "impl", - "type": "address" - } - ], - "stateMutability": "view", - "type": "function" - } - ], - "transactionHash": "0x04ed90cf14ae07fd76f9b42920992522f48fae8e72491e82c69a360cd5246357", - "receipt": { - "to": null, - "from": "0x346658f99924B8Cfe8b6A2418070192385848CA9", - "contractAddress": "0x72Dc614736Fd5A3cCc805e654530F7229710c8e3", - "transactionIndex": 4, - "gasUsed": "1467647", - "logsBloom": "0x00000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000008000010000000000000000000000000020000400000000000000800000000000000000000000001000000400000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000", - "blockHash": "0xc7da63fa3a815405926fc417b6ddb2dcf73016c12478a0c848068f7051fbc89a", - "transactionHash": "0x04ed90cf14ae07fd76f9b42920992522f48fae8e72491e82c69a360cd5246357", - "logs": [ - { - "transactionIndex": 4, - "blockNumber": 1705149, - "transactionHash": "0x04ed90cf14ae07fd76f9b42920992522f48fae8e72491e82c69a360cd5246357", - "address": "0x72Dc614736Fd5A3cCc805e654530F7229710c8e3", - "topics": [ - "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x000000000000000000000000346658f99924b8cfe8b6a2418070192385848ca9" - ], - "data": "0x", - "logIndex": 3, - "blockHash": "0xc7da63fa3a815405926fc417b6ddb2dcf73016c12478a0c848068f7051fbc89a" - } - ], - "blockNumber": 1705149, - "cumulativeGasUsed": "1674523", - "status": 1, - "byzantium": true - }, - "args": [], - "numDeployments": 1, - "solcInputHash": "32801c180c72a260c0a67f69b3ec7a05", - "metadata": "{\"compiler\":{\"version\":\"0.8.13+commit.abaa5c0e\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"gnosisSafe\",\"type\":\"address\"}],\"name\":\"GnosisWrapperCreated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"semanticVersion\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"frontendURI\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"impl\",\"type\":\"address\"}],\"name\":\"VersionCreated\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"_semanticVersion\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"_frontendURI\",\"type\":\"string\"},{\"internalType\":\"address\",\"name\":\"_impl\",\"type\":\"address\"}],\"name\":\"addVersion\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"creator\",\"type\":\"address\"},{\"internalType\":\"bytes[]\",\"name\":\"data\",\"type\":\"bytes[]\"}],\"name\":\"create\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"\",\"type\":\"address[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"versionControl\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"semanticVersion\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"frontendURI\",\"type\":\"string\"},{\"internalType\":\"address\",\"name\":\"impl\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"details\":\"GnosisWrapper Factory used to deploy Gnosis Modules\",\"kind\":\"dev\",\"methods\":{\"addVersion(string,string,address)\":{\"details\":\"add a new version to update module users\",\"params\":{\"_frontendURI\":\"IPFS hash of the static frontend\",\"_impl\":\"address of the impl\",\"_semanticVersion\":\"semantic version control\"}},\"create(address,bytes[])\":{\"details\":\"Creates a GnosisWrapper module\",\"params\":{\"creator\":\"The address creating the module\",\"data\":\"The array of bytes used to create the module\"},\"returns\":{\"_0\":\"address[] The array of addresses of the created module\"}},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner.\"},\"supportsInterface(bytes4)\":{\"details\":\"See {IERC165-supportsInterface}.\"},\"transferOwnership(address)\":{\"details\":\"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/GnosisWrapperFactory.sol\":\"GnosisWrapperFactory\"},\"evmVersion\":\"london\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@fractal-framework/core-contracts/contracts/ModuleBase.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\\\";\\r\\nimport \\\"@openzeppelin/contracts/utils/introspection/ERC165Storage.sol\\\";\\r\\nimport \\\"./interfaces/IModuleBase.sol\\\";\\r\\n\\r\\n/// @notice An abstract contract to be inherited by module contracts\\r\\nabstract contract ModuleBase is IModuleBase, UUPSUpgradeable, ERC165Storage {\\r\\n IDAOAccessControl public accessControl;\\r\\n address public moduleFactory;\\r\\n string internal _name;\\r\\n\\r\\n /// @notice Requires that a function caller has the associated role\\r\\n modifier authorized() {\\r\\n if (\\r\\n !accessControl.actionIsAuthorized(\\r\\n msg.sender,\\r\\n address(this),\\r\\n msg.sig\\r\\n )\\r\\n ) {\\r\\n revert NotAuthorized();\\r\\n }\\r\\n _;\\r\\n }\\r\\n\\r\\n /// @notice Function for initializing the contract that can only be called once\\r\\n /// @param _accessControl The address of the access control contract\\r\\n /// @param _moduleFactory The address of the factory deploying the module\\r\\n /// @param __name Human readable string of the module name\\r\\n function __initBase(address _accessControl, address _moduleFactory, string memory __name)\\r\\n internal\\r\\n onlyInitializing\\r\\n {\\r\\n accessControl = IDAOAccessControl(_accessControl);\\r\\n moduleFactory = _moduleFactory;\\r\\n _name = __name;\\r\\n __UUPSUpgradeable_init();\\r\\n _registerInterface(type(IModuleBase).interfaceId);\\r\\n }\\r\\n\\r\\n /// @dev Applies authorized modifier so that an upgrade require the caller to have the correct role\\r\\n /// @param newImplementation The address of the new implementation contract being upgraded to\\r\\n function _authorizeUpgrade(address newImplementation)\\r\\n internal\\r\\n override\\r\\n authorized\\r\\n {}\\r\\n\\r\\n /// @notice Returns the module name\\r\\n /// @return The module name\\r\\n function name() public view virtual returns (string memory) {\\r\\n return _name;\\r\\n }\\r\\n}\\r\\n\",\"keccak256\":\"0xdd4b440c6924fe479e6e3c72e35d109c3af3a9eeb72eab85c65bbe31a2b05dcf\",\"license\":\"Unlicense\"},\"@fractal-framework/core-contracts/contracts/ModuleFactoryBase.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\r\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\\\";\\r\\nimport \\\"@openzeppelin/contracts/utils/introspection/ERC165Storage.sol\\\";\\r\\nimport \\\"./interfaces/IModuleFactoryBase.sol\\\";\\r\\n\\r\\n/// @notice An abstract contract to be inherited by module contracts\\r\\nabstract contract ModuleFactoryBase is\\r\\n IModuleFactoryBase,\\r\\n Ownable,\\r\\n Initializable,\\r\\n ERC165Storage\\r\\n{\\r\\n VersionInfo[] public versionControl;\\r\\n\\r\\n /// @dev add a new version to update module users\\r\\n /// @param _semanticVersion semantic version control\\r\\n /// @param _frontendURI IPFS hash of the static frontend\\r\\n /// @param _impl address of the impl\\r\\n function addVersion(\\r\\n string calldata _semanticVersion,\\r\\n string calldata _frontendURI,\\r\\n address _impl\\r\\n ) external onlyOwner {\\r\\n versionControl.push(VersionInfo(_semanticVersion, _frontendURI, _impl));\\r\\n emit VersionCreated(_semanticVersion, _frontendURI, _impl);\\r\\n }\\r\\n\\r\\n /// @dev Creates a module\\r\\n /// @param creator The address creating the module\\r\\n /// @param data The array of bytes used to create the module\\r\\n /// @return address[] Array of the created module addresses\\r\\n function create(address creator, bytes[] calldata data)\\r\\n external\\r\\n virtual\\r\\n returns (address[] memory);\\r\\n\\r\\n /// @notice Function for initializing the contract that can only be called once\\r\\n function __initFactoryBase() internal onlyInitializing {\\r\\n _registerInterface(type(IModuleFactoryBase).interfaceId);\\r\\n }\\r\\n}\\r\\n\",\"keccak256\":\"0x0720f0e7ad48db40d88974112914d7c374c8e6309285b14a29c53a4a5412b0f2\",\"license\":\"Unlicense\"},\"@fractal-framework/core-contracts/contracts/interfaces/IDAOAccessControl.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\ninterface IDAOAccessControl {\\r\\n struct RoleData {\\r\\n mapping(address => bool) members;\\r\\n string adminRole;\\r\\n }\\r\\n\\r\\n error UnequalArrayLengths();\\r\\n error MissingRole(address account, string role);\\r\\n error OnlySelfRenounce();\\r\\n\\r\\n event ActionRoleAdded(\\r\\n address target,\\r\\n string functionDesc,\\r\\n bytes4 encodedSig,\\r\\n string role\\r\\n );\\r\\n event ActionRoleRemoved(\\r\\n address target,\\r\\n string functionDesc,\\r\\n bytes4 encodedSig,\\r\\n string role\\r\\n );\\r\\n event RoleAdminChanged(\\r\\n string role,\\r\\n string previousAdminRole,\\r\\n string adminRole\\r\\n );\\r\\n event RoleGranted(string role, address account, address admin);\\r\\n event RoleRevoked(string role, address account, address admin);\\r\\n\\r\\n /// @notice Initialize DAO action and role permissions\\r\\n /// @param dao Address to receive DAO role\\r\\n /// @param roles What permissions are assigned to\\r\\n /// @param roleAdmins Roles which have the ability to remove or add members\\r\\n /// @param members Addresses to be granted the specified roles\\r\\n /// @param targets Contract addresses for actions to be defined on\\r\\n /// @param functionDescs Function descriptions used to define actions\\r\\n /// @param actionRoles Roles being granted permission for an action\\r\\n function initialize(\\r\\n address dao,\\r\\n string[] memory roles,\\r\\n string[] memory roleAdmins,\\r\\n address[][] memory members,\\r\\n address[] memory targets,\\r\\n string[] memory functionDescs,\\r\\n string[][] memory actionRoles\\r\\n ) external;\\r\\n\\r\\n /// @notice Grants roles to the specified addresses and defines admin roles\\r\\n /// @notice This function can only be called by the DAO\\r\\n /// @param roles The roles being granted\\r\\n /// @param roleAdmins The roles being granted as admins of the specified of roles\\r\\n /// @param members Addresses being granted each specified role\\r\\n function daoGrantRolesAndAdmins(\\r\\n string[] memory roles,\\r\\n string[] memory roleAdmins,\\r\\n address[][] memory members\\r\\n ) external;\\r\\n\\r\\n /// @notice Grants roles to the specified addresses\\r\\n /// @notice This function can only be called by the DAO\\r\\n /// @param roles The roles being granted\\r\\n /// @param members Addresses being granted each specified role\\r\\n function daoGrantRoles(string[] memory roles, address[][] memory members)\\r\\n external;\\r\\n\\r\\n /// @notice Authorizes roles to execute the specified actions\\r\\n /// @notice This function can only be called by the DAO\\r\\n /// @param targets The contract addresses that the action functions are implemented on\\r\\n /// @param functionDescs The function descriptions used to define the actions\\r\\n /// @param roles Roles being granted permission for an action\\r\\n function daoAddActionsRoles(\\r\\n address[] memory targets,\\r\\n string[] memory functionDescs,\\r\\n string[][] memory roles\\r\\n ) external;\\r\\n\\r\\n /// @notice Removes autorization for roles to execute the specified actions\\r\\n /// @notice This function can only be called by the DAO\\r\\n /// @param targets The contract addresses that the action functions are implemented on\\r\\n /// @param functionDescs The function description used to define the actions\\r\\n /// @param roles Roles that action permissions are being removed on\\r\\n function daoRemoveActionsRoles(\\r\\n address[] memory targets,\\r\\n string[] memory functionDescs,\\r\\n string[][] memory roles\\r\\n ) external;\\r\\n\\r\\n /// @notice Grants a role to the specified address\\r\\n /// @notice This function can only be called by an admin of the specified role\\r\\n /// @param role The role being granted\\r\\n /// @param account The address being granted the specified role\\r\\n function adminGrantRole(string memory role, address account)\\r\\n external;\\r\\n\\r\\n /// @notice Revokes a role from the specified address\\r\\n /// @notice This function can only be called by an admin of the specified role\\r\\n /// @param role The role being revoked\\r\\n /// @param account The address the role is being revoked from\\r\\n function adminRevokeRole(string memory role, address account)\\r\\n external;\\r\\n\\r\\n /// @notice Enables an address to remove one of its own roles\\r\\n /// @notice This function can only be called by the account specified\\r\\n /// @param role The role being renounced\\r\\n /// @param account The address renouncing the role\\r\\n function userRenounceRole(string memory role, address account) external;\\r\\n\\r\\n /// @notice Checks if a caller has the permissions to execute the specific action\\r\\n /// @param caller Address attempting to execute the action\\r\\n /// @param target Contract address corresponding to the action\\r\\n /// @param sig The function signature used to define the action\\r\\n function actionIsAuthorized(\\r\\n address caller,\\r\\n address target,\\r\\n bytes4 sig\\r\\n ) external view returns (bool isAuthorized);\\r\\n\\r\\n /// @notice Returns the roles autorized to execute the specified action\\r\\n /// @param target Contract address corresponding to the action\\r\\n /// @param functionDesc The function description used to define the action\\r\\n function getActionRoles(address target, string memory functionDesc)\\r\\n external\\r\\n view\\r\\n returns (string[] memory roles);\\r\\n\\r\\n /// @notice Checks if a specific role is authorized for an action\\r\\n /// @param role Role that authorization is being checked on\\r\\n /// @param target Contract address corresponding to the action\\r\\n /// @param functionDesc Function description used to define the action\\r\\n /// @return isAuthorized Indicates whether the role is authorized to execute the action\\r\\n function isRoleAuthorized(\\r\\n string calldata role,\\r\\n address target,\\r\\n string memory functionDesc\\r\\n ) external view returns (bool isAuthorized);\\r\\n\\r\\n /// @notice Returns whether the account has been granted the role\\r\\n /// @param role Role that authorization is being checked on\\r\\n /// @param account Address that the role authorization is being check on\\r\\n /// @return boolean Indicates whether the address has been granted the role\\r\\n function hasRole(string memory role, address account)\\r\\n external\\r\\n view\\r\\n returns (bool);\\r\\n\\r\\n /// @notice Returns the role that is the admin of the specified role\\r\\n /// @param role Role that the admin role is being returned for\\r\\n /// @return string The admin role of the specified role\\r\\n function getRoleAdmin(string memory role)\\r\\n external\\r\\n view\\r\\n returns (string memory);\\r\\n\\r\\n /// @return string The string \\\"DAO_ROLE\\\"\\r\\n function DAO_ROLE() external view returns (string memory);\\r\\n}\\r\\n\",\"keccak256\":\"0x8862f578b4fe6a79370b5cbe896e59df4722e95dbb1b0d2e286e335915ed616c\",\"license\":\"Unlicense\"},\"@fractal-framework/core-contracts/contracts/interfaces/IModuleBase.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\nimport \\\"./IDAOAccessControl.sol\\\";\\r\\n\\r\\ninterface IModuleBase {\\r\\n error NotAuthorized();\\r\\n\\r\\n /// @return IDAOAccessControl The Access control interface\\r\\n function accessControl() external view returns (IDAOAccessControl);\\r\\n\\r\\n /// @return string The string \\\"Name\\\"\\r\\n function name() external view returns (string memory);\\r\\n}\\r\\n\",\"keccak256\":\"0xf7aa0a6fc64e3ea68e1fe799390408e62bfd9d1339d6c31c6d862f3af158cca6\",\"license\":\"Unlicense\"},\"@fractal-framework/core-contracts/contracts/interfaces/IModuleFactoryBase.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\n/// @dev The interface to be inherited by Fractal module factories\\r\\ninterface IModuleFactoryBase {\\r\\n event VersionCreated(\\r\\n string semanticVersion,\\r\\n string frontendURI,\\r\\n address impl\\r\\n );\\r\\n struct VersionInfo {\\r\\n string semanticVersion;\\r\\n string frontendURI;\\r\\n address impl;\\r\\n }\\r\\n\\r\\n /// @dev add a new version to update module users\\r\\n /// @param _semanticVersion semantic version control\\r\\n /// @param _frontendURI IPFS hash of the static frontend\\r\\n /// @param _impl address of the impl\\r\\n function addVersion(\\r\\n string calldata _semanticVersion,\\r\\n string calldata _frontendURI,\\r\\n address _impl\\r\\n ) external;\\r\\n\\r\\n /// @dev Creates a module\\r\\n /// @param creator The address creating the module\\r\\n /// @param data The array of bytes used to create the module\\r\\n /// @return address[] Array of the created module addresses\\r\\n function create(address creator, bytes[] calldata data)\\r\\n external\\r\\n returns (address[] memory);\\r\\n}\\r\\n\",\"keccak256\":\"0xefce9f923254a93b1d9d81c56461c04eaf80bc25a741031119562b42a366a049\",\"license\":\"Unlicense\"},\"@openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified\\n * proxy whose upgrades are fully controlled by the current implementation.\\n */\\ninterface IERC1822ProxiableUpgradeable {\\n /**\\n * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation\\n * address.\\n *\\n * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\\n * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\\n * function revert if invoked through a proxy.\\n */\\n function proxiableUUID() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0x77c89f893e403efc6929ba842b7ccf6534d4ffe03afe31670b4a528c0ad78c0f\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/ERC1967/ERC1967UpgradeUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../beacon/IBeaconUpgradeable.sol\\\";\\nimport \\\"../../interfaces/draft-IERC1822Upgradeable.sol\\\";\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\nimport \\\"../../utils/StorageSlotUpgradeable.sol\\\";\\nimport \\\"../utils/Initializable.sol\\\";\\n\\n/**\\n * @dev This abstract contract provides getters and event emitting update functions for\\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.\\n *\\n * _Available since v4.1._\\n *\\n * @custom:oz-upgrades-unsafe-allow delegatecall\\n */\\nabstract contract ERC1967UpgradeUpgradeable is Initializable {\\n function __ERC1967Upgrade_init() internal onlyInitializing {\\n }\\n\\n function __ERC1967Upgrade_init_unchained() internal onlyInitializing {\\n }\\n // This is the keccak-256 hash of \\\"eip1967.proxy.rollback\\\" subtracted by 1\\n bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;\\n\\n /**\\n * @dev Storage slot with the address of the current implementation.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.implementation\\\" subtracted by 1, and is\\n * validated in the constructor.\\n */\\n bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n /**\\n * @dev Emitted when the implementation is upgraded.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function _getImplementation() internal view returns (address) {\\n return StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new address in the EIP1967 implementation slot.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(AddressUpgradeable.isContract(newImplementation), \\\"ERC1967: new implementation is not a contract\\\");\\n StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\\n }\\n\\n /**\\n * @dev Perform implementation upgrade\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeTo(address newImplementation) internal {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Perform implementation upgrade with additional setup call.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeToAndCall(\\n address newImplementation,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n _upgradeTo(newImplementation);\\n if (data.length > 0 || forceCall) {\\n _functionDelegateCall(newImplementation, data);\\n }\\n }\\n\\n /**\\n * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeToAndCallUUPS(\\n address newImplementation,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n // Upgrades from old implementations will perform a rollback test. This test requires the new\\n // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing\\n // this special case will break upgrade paths from old UUPS implementation to new ones.\\n if (StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT).value) {\\n _setImplementation(newImplementation);\\n } else {\\n try IERC1822ProxiableUpgradeable(newImplementation).proxiableUUID() returns (bytes32 slot) {\\n require(slot == _IMPLEMENTATION_SLOT, \\\"ERC1967Upgrade: unsupported proxiableUUID\\\");\\n } catch {\\n revert(\\\"ERC1967Upgrade: new implementation is not UUPS\\\");\\n }\\n _upgradeToAndCall(newImplementation, data, forceCall);\\n }\\n }\\n\\n /**\\n * @dev Storage slot with the admin of the contract.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.admin\\\" subtracted by 1, and is\\n * validated in the constructor.\\n */\\n bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\\n\\n /**\\n * @dev Emitted when the admin account has changed.\\n */\\n event AdminChanged(address previousAdmin, address newAdmin);\\n\\n /**\\n * @dev Returns the current admin.\\n */\\n function _getAdmin() internal view returns (address) {\\n return StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new address in the EIP1967 admin slot.\\n */\\n function _setAdmin(address newAdmin) private {\\n require(newAdmin != address(0), \\\"ERC1967: new admin is the zero address\\\");\\n StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value = newAdmin;\\n }\\n\\n /**\\n * @dev Changes the admin of the proxy.\\n *\\n * Emits an {AdminChanged} event.\\n */\\n function _changeAdmin(address newAdmin) internal {\\n emit AdminChanged(_getAdmin(), newAdmin);\\n _setAdmin(newAdmin);\\n }\\n\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Emitted when the beacon is upgraded.\\n */\\n event BeaconUpgraded(address indexed beacon);\\n\\n /**\\n * @dev Returns the current beacon.\\n */\\n function _getBeacon() internal view returns (address) {\\n return StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new beacon in the EIP1967 beacon slot.\\n */\\n function _setBeacon(address newBeacon) private {\\n require(AddressUpgradeable.isContract(newBeacon), \\\"ERC1967: new beacon is not a contract\\\");\\n require(\\n AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()),\\n \\\"ERC1967: beacon implementation is not a contract\\\"\\n );\\n StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value = newBeacon;\\n }\\n\\n /**\\n * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does\\n * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).\\n *\\n * Emits a {BeaconUpgraded} event.\\n */\\n function _upgradeBeaconToAndCall(\\n address newBeacon,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n _setBeacon(newBeacon);\\n emit BeaconUpgraded(newBeacon);\\n if (data.length > 0 || forceCall) {\\n _functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data);\\n }\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function _functionDelegateCall(address target, bytes memory data) private returns (bytes memory) {\\n require(AddressUpgradeable.isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return AddressUpgradeable.verifyCallResult(success, returndata, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x315887e846f1e5f8d8fa535a229d318bb9290aaa69485117f1ee8a9a6b3be823\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/beacon/IBeaconUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeaconUpgradeable {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x24b86ac8c005b8c654fbf6ac34a5a4f61580d7273541e83e013e89d66fbf0908\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\\n * reused. This mechanism prevents re-execution of each \\\"step\\\" but allows the creation of new initialization steps in\\n * case an upgrade adds a module that needs to be initialized.\\n *\\n * For example:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * contract MyToken is ERC20Upgradeable {\\n * function initialize() initializer public {\\n * __ERC20_init(\\\"MyToken\\\", \\\"MTK\\\");\\n * }\\n * }\\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\\n * function initializeV2() reinitializer(2) public {\\n * __ERC20Permit_init(\\\"MyToken\\\");\\n * }\\n * }\\n * ```\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n *\\n * [CAUTION]\\n * ====\\n * Avoid leaving a contract uninitialized.\\n *\\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * /// @custom:oz-upgrades-unsafe-allow constructor\\n * constructor() {\\n * _disableInitializers();\\n * }\\n * ```\\n * ====\\n */\\nabstract contract Initializable {\\n /**\\n * @dev Indicates that the contract has been initialized.\\n * @custom:oz-retyped-from bool\\n */\\n uint8 private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Triggered when the contract has been initialized or reinitialized.\\n */\\n event Initialized(uint8 version);\\n\\n /**\\n * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\\n * `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`.\\n */\\n modifier initializer() {\\n bool isTopLevelCall = !_initializing;\\n require(\\n (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\\n \\\"Initializable: contract is already initialized\\\"\\n );\\n _initialized = 1;\\n if (isTopLevelCall) {\\n _initializing = true;\\n }\\n _;\\n if (isTopLevelCall) {\\n _initializing = false;\\n emit Initialized(1);\\n }\\n }\\n\\n /**\\n * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\\n * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\\n * used to initialize parent contracts.\\n *\\n * `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original\\n * initialization step. This is essential to configure modules that are added through upgrades and that require\\n * initialization.\\n *\\n * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\\n * a contract, executing them in the right order is up to the developer or operator.\\n */\\n modifier reinitializer(uint8 version) {\\n require(!_initializing && _initialized < version, \\\"Initializable: contract is already initialized\\\");\\n _initialized = version;\\n _initializing = true;\\n _;\\n _initializing = false;\\n emit Initialized(version);\\n }\\n\\n /**\\n * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\\n * {initializer} and {reinitializer} modifiers, directly or indirectly.\\n */\\n modifier onlyInitializing() {\\n require(_initializing, \\\"Initializable: contract is not initializing\\\");\\n _;\\n }\\n\\n /**\\n * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\\n * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\\n * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\\n * through proxies.\\n */\\n function _disableInitializers() internal virtual {\\n require(!_initializing, \\\"Initializable: contract is initializing\\\");\\n if (_initialized < type(uint8).max) {\\n _initialized = type(uint8).max;\\n emit Initialized(type(uint8).max);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0203dcadc5737d9ef2c211d6fa15d18ebc3b30dfa51903b64870b01a062b0b4e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (proxy/utils/UUPSUpgradeable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../interfaces/draft-IERC1822Upgradeable.sol\\\";\\nimport \\\"../ERC1967/ERC1967UpgradeUpgradeable.sol\\\";\\nimport \\\"./Initializable.sol\\\";\\n\\n/**\\n * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an\\n * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.\\n *\\n * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is\\n * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing\\n * `UUPSUpgradeable` with a custom implementation of upgrades.\\n *\\n * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.\\n *\\n * _Available since v4.1._\\n */\\nabstract contract UUPSUpgradeable is Initializable, IERC1822ProxiableUpgradeable, ERC1967UpgradeUpgradeable {\\n function __UUPSUpgradeable_init() internal onlyInitializing {\\n }\\n\\n function __UUPSUpgradeable_init_unchained() internal onlyInitializing {\\n }\\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment\\n address private immutable __self = address(this);\\n\\n /**\\n * @dev Check that the execution is being performed through a delegatecall call and that the execution context is\\n * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case\\n * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a\\n * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to\\n * fail.\\n */\\n modifier onlyProxy() {\\n require(address(this) != __self, \\\"Function must be called through delegatecall\\\");\\n require(_getImplementation() == __self, \\\"Function must be called through active proxy\\\");\\n _;\\n }\\n\\n /**\\n * @dev Check that the execution is not being performed through a delegate call. This allows a function to be\\n * callable on the implementing contract but not through proxies.\\n */\\n modifier notDelegated() {\\n require(address(this) == __self, \\\"UUPSUpgradeable: must not be called through delegatecall\\\");\\n _;\\n }\\n\\n /**\\n * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the\\n * implementation. It is used to validate that the this implementation remains valid after an upgrade.\\n *\\n * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\\n * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\\n * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.\\n */\\n function proxiableUUID() external view virtual override notDelegated returns (bytes32) {\\n return _IMPLEMENTATION_SLOT;\\n }\\n\\n /**\\n * @dev Upgrade the implementation of the proxy to `newImplementation`.\\n *\\n * Calls {_authorizeUpgrade}.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function upgradeTo(address newImplementation) external virtual onlyProxy {\\n _authorizeUpgrade(newImplementation);\\n _upgradeToAndCallUUPS(newImplementation, new bytes(0), false);\\n }\\n\\n /**\\n * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call\\n * encoded in `data`.\\n *\\n * Calls {_authorizeUpgrade}.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function upgradeToAndCall(address newImplementation, bytes memory data) external payable virtual onlyProxy {\\n _authorizeUpgrade(newImplementation);\\n _upgradeToAndCallUUPS(newImplementation, data, true);\\n }\\n\\n /**\\n * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by\\n * {upgradeTo} and {upgradeToAndCall}.\\n *\\n * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.\\n *\\n * ```solidity\\n * function _authorizeUpgrade(address) internal override onlyOwner {}\\n * ```\\n */\\n function _authorizeUpgrade(address newImplementation) internal virtual;\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x6e36e9b4b71de699c2f3f0d4e4d1aa0b35da99a26e8d5b91ef09ba234b4ef270\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x611aa3f23e59cfdd1863c536776407b3e33d695152a266fa7cfb34440a29a8a3\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StorageSlotUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for reading and writing primitive types to specific storage slots.\\n *\\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\\n * This library helps with reading and writing to such slots without the need for inline assembly.\\n *\\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\\n *\\n * Example usage to set ERC1967 implementation slot:\\n * ```\\n * contract ERC1967 {\\n * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n *\\n * function _getImplementation() internal view returns (address) {\\n * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\\n * }\\n *\\n * function _setImplementation(address newImplementation) internal {\\n * require(Address.isContract(newImplementation), \\\"ERC1967: new implementation is not a contract\\\");\\n * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\\n * }\\n * }\\n * ```\\n *\\n * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._\\n */\\nlibrary StorageSlotUpgradeable {\\n struct AddressSlot {\\n address value;\\n }\\n\\n struct BooleanSlot {\\n bool value;\\n }\\n\\n struct Bytes32Slot {\\n bytes32 value;\\n }\\n\\n struct Uint256Slot {\\n uint256 value;\\n }\\n\\n /**\\n * @dev Returns an `AddressSlot` with member `value` located at `slot`.\\n */\\n function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\\n */\\n function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\\n */\\n function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\\n */\\n function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n}\\n\",\"keccak256\":\"0x09864aea84f01e39313375b5610c73a3c1c68abbdc51e5ccdd25ff977fdadf9a\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor() {\\n _transferOwnership(_msgSender());\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n _checkOwner();\\n _;\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if the sender is not the owner.\\n */\\n function _checkOwner() internal view virtual {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n _transferOwnership(address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n _transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n address oldOwner = _owner;\\n _owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner);\\n }\\n}\\n\",\"keccak256\":\"0xa94b34880e3c1b0b931662cb1c09e5dfa6662f31cba80e07c5ee71cd135c9673\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/draft-IERC1822.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified\\n * proxy whose upgrades are fully controlled by the current implementation.\\n */\\ninterface IERC1822Proxiable {\\n /**\\n * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation\\n * address.\\n *\\n * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\\n * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\\n * function revert if invoked through a proxy.\\n */\\n function proxiableUUID() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0x1d4afe6cb24200cc4545eed814ecf5847277dfe5d613a1707aad5fceecebcfff\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (proxy/ERC1967/ERC1967Proxy.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../Proxy.sol\\\";\\nimport \\\"./ERC1967Upgrade.sol\\\";\\n\\n/**\\n * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an\\n * implementation address that can be changed. This address is stored in storage in the location specified by\\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the\\n * implementation behind the proxy.\\n */\\ncontract ERC1967Proxy is Proxy, ERC1967Upgrade {\\n /**\\n * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.\\n *\\n * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded\\n * function call, and allows initializing the storage of the proxy like a Solidity constructor.\\n */\\n constructor(address _logic, bytes memory _data) payable {\\n _upgradeToAndCall(_logic, _data, false);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function _implementation() internal view virtual override returns (address impl) {\\n return ERC1967Upgrade._getImplementation();\\n }\\n}\\n\",\"keccak256\":\"0xa2b22da3032e50b55f95ec1d13336102d675f341167aa76db571ef7f8bb7975d\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/ERC1967/ERC1967Upgrade.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../beacon/IBeacon.sol\\\";\\nimport \\\"../../interfaces/draft-IERC1822.sol\\\";\\nimport \\\"../../utils/Address.sol\\\";\\nimport \\\"../../utils/StorageSlot.sol\\\";\\n\\n/**\\n * @dev This abstract contract provides getters and event emitting update functions for\\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.\\n *\\n * _Available since v4.1._\\n *\\n * @custom:oz-upgrades-unsafe-allow delegatecall\\n */\\nabstract contract ERC1967Upgrade {\\n // This is the keccak-256 hash of \\\"eip1967.proxy.rollback\\\" subtracted by 1\\n bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;\\n\\n /**\\n * @dev Storage slot with the address of the current implementation.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.implementation\\\" subtracted by 1, and is\\n * validated in the constructor.\\n */\\n bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n /**\\n * @dev Emitted when the implementation is upgraded.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function _getImplementation() internal view returns (address) {\\n return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new address in the EIP1967 implementation slot.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(Address.isContract(newImplementation), \\\"ERC1967: new implementation is not a contract\\\");\\n StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\\n }\\n\\n /**\\n * @dev Perform implementation upgrade\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeTo(address newImplementation) internal {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Perform implementation upgrade with additional setup call.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeToAndCall(\\n address newImplementation,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n _upgradeTo(newImplementation);\\n if (data.length > 0 || forceCall) {\\n Address.functionDelegateCall(newImplementation, data);\\n }\\n }\\n\\n /**\\n * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeToAndCallUUPS(\\n address newImplementation,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n // Upgrades from old implementations will perform a rollback test. This test requires the new\\n // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing\\n // this special case will break upgrade paths from old UUPS implementation to new ones.\\n if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {\\n _setImplementation(newImplementation);\\n } else {\\n try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {\\n require(slot == _IMPLEMENTATION_SLOT, \\\"ERC1967Upgrade: unsupported proxiableUUID\\\");\\n } catch {\\n revert(\\\"ERC1967Upgrade: new implementation is not UUPS\\\");\\n }\\n _upgradeToAndCall(newImplementation, data, forceCall);\\n }\\n }\\n\\n /**\\n * @dev Storage slot with the admin of the contract.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.admin\\\" subtracted by 1, and is\\n * validated in the constructor.\\n */\\n bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\\n\\n /**\\n * @dev Emitted when the admin account has changed.\\n */\\n event AdminChanged(address previousAdmin, address newAdmin);\\n\\n /**\\n * @dev Returns the current admin.\\n */\\n function _getAdmin() internal view returns (address) {\\n return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new address in the EIP1967 admin slot.\\n */\\n function _setAdmin(address newAdmin) private {\\n require(newAdmin != address(0), \\\"ERC1967: new admin is the zero address\\\");\\n StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;\\n }\\n\\n /**\\n * @dev Changes the admin of the proxy.\\n *\\n * Emits an {AdminChanged} event.\\n */\\n function _changeAdmin(address newAdmin) internal {\\n emit AdminChanged(_getAdmin(), newAdmin);\\n _setAdmin(newAdmin);\\n }\\n\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Emitted when the beacon is upgraded.\\n */\\n event BeaconUpgraded(address indexed beacon);\\n\\n /**\\n * @dev Returns the current beacon.\\n */\\n function _getBeacon() internal view returns (address) {\\n return StorageSlot.getAddressSlot(_BEACON_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new beacon in the EIP1967 beacon slot.\\n */\\n function _setBeacon(address newBeacon) private {\\n require(Address.isContract(newBeacon), \\\"ERC1967: new beacon is not a contract\\\");\\n require(\\n Address.isContract(IBeacon(newBeacon).implementation()),\\n \\\"ERC1967: beacon implementation is not a contract\\\"\\n );\\n StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;\\n }\\n\\n /**\\n * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does\\n * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).\\n *\\n * Emits a {BeaconUpgraded} event.\\n */\\n function _upgradeBeaconToAndCall(\\n address newBeacon,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n _setBeacon(newBeacon);\\n emit BeaconUpgraded(newBeacon);\\n if (data.length > 0 || forceCall) {\\n Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xabf3f59bc0e5423eae45e459dbe92e7052c6983628d39008590edc852a62f94a\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internal call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overridden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internal call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback() external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive() external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overridden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {}\\n}\\n\",\"keccak256\":\"0xc130fe33f1b2132158531a87734153293f6d07bc263ff4ac90e85da9c82c0e27\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0xd50a3421ac379ccb1be435fa646d66a65c986b4924f0849839f08692f39dde61\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd6153ce99bcdcce22b124f755e72553295be6abcd63804cfdffceb188b8bef10\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0xe2e337e6dde9ef6b680e07338c493ebea1b5fd09b43424112868e9cc1706bca7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Create2.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Create2.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Helper to make usage of the `CREATE2` EVM opcode easier and safer.\\n * `CREATE2` can be used to compute in advance the address where a smart\\n * contract will be deployed, which allows for interesting new mechanisms known\\n * as 'counterfactual interactions'.\\n *\\n * See the https://eips.ethereum.org/EIPS/eip-1014#motivation[EIP] for more\\n * information.\\n */\\nlibrary Create2 {\\n /**\\n * @dev Deploys a contract using `CREATE2`. The address where the contract\\n * will be deployed can be known in advance via {computeAddress}.\\n *\\n * The bytecode for a contract can be obtained from Solidity with\\n * `type(contractName).creationCode`.\\n *\\n * Requirements:\\n *\\n * - `bytecode` must not be empty.\\n * - `salt` must have not been used for `bytecode` already.\\n * - the factory must have a balance of at least `amount`.\\n * - if `amount` is non-zero, `bytecode` must have a `payable` constructor.\\n */\\n function deploy(\\n uint256 amount,\\n bytes32 salt,\\n bytes memory bytecode\\n ) internal returns (address) {\\n address addr;\\n require(address(this).balance >= amount, \\\"Create2: insufficient balance\\\");\\n require(bytecode.length != 0, \\\"Create2: bytecode length is zero\\\");\\n /// @solidity memory-safe-assembly\\n assembly {\\n addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt)\\n }\\n require(addr != address(0), \\\"Create2: Failed on deploy\\\");\\n return addr;\\n }\\n\\n /**\\n * @dev Returns the address where a contract will be stored if deployed via {deploy}. Any change in the\\n * `bytecodeHash` or `salt` will result in a new destination address.\\n */\\n function computeAddress(bytes32 salt, bytes32 bytecodeHash) internal view returns (address) {\\n return computeAddress(salt, bytecodeHash, address(this));\\n }\\n\\n /**\\n * @dev Returns the address where a contract will be stored if deployed via {deploy} from a contract located at\\n * `deployer`. If `deployer` is this contract's address, returns the same value as {computeAddress}.\\n */\\n function computeAddress(\\n bytes32 salt,\\n bytes32 bytecodeHash,\\n address deployer\\n ) internal pure returns (address) {\\n bytes32 _data = keccak256(abi.encodePacked(bytes1(0xff), deployer, salt, bytecodeHash));\\n return address(uint160(uint256(_data)));\\n }\\n}\\n\",\"keccak256\":\"0x62237e1773cbf99739b7019f3772a2ff5360d56edb69751b513237f5fcd78571\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/StorageSlot.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for reading and writing primitive types to specific storage slots.\\n *\\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\\n * This library helps with reading and writing to such slots without the need for inline assembly.\\n *\\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\\n *\\n * Example usage to set ERC1967 implementation slot:\\n * ```\\n * contract ERC1967 {\\n * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n *\\n * function _getImplementation() internal view returns (address) {\\n * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\\n * }\\n *\\n * function _setImplementation(address newImplementation) internal {\\n * require(Address.isContract(newImplementation), \\\"ERC1967: new implementation is not a contract\\\");\\n * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\\n * }\\n * }\\n * ```\\n *\\n * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._\\n */\\nlibrary StorageSlot {\\n struct AddressSlot {\\n address value;\\n }\\n\\n struct BooleanSlot {\\n bool value;\\n }\\n\\n struct Bytes32Slot {\\n bytes32 value;\\n }\\n\\n struct Uint256Slot {\\n uint256 value;\\n }\\n\\n /**\\n * @dev Returns an `AddressSlot` with member `value` located at `slot`.\\n */\\n function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\\n */\\n function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\\n */\\n function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\\n */\\n function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd5c50c54bf02740ebd122ff06832546cb5fa84486d52695a9ccfd11666e0c81d\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/ERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165 is IERC165 {\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165).interfaceId;\\n }\\n}\\n\",\"keccak256\":\"0xd10975de010d89fd1c78dc5e8a9a7e7f496198085c151648f20cba166b32582b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/ERC165Storage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165Storage.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./ERC165.sol\\\";\\n\\n/**\\n * @dev Storage based implementation of the {IERC165} interface.\\n *\\n * Contracts may inherit from this and call {_registerInterface} to declare\\n * their support of an interface.\\n */\\nabstract contract ERC165Storage is ERC165 {\\n /**\\n * @dev Mapping of interface ids to whether or not it's supported.\\n */\\n mapping(bytes4 => bool) private _supportedInterfaces;\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return super.supportsInterface(interfaceId) || _supportedInterfaces[interfaceId];\\n }\\n\\n /**\\n * @dev Registers the contract as an implementer of the interface defined by\\n * `interfaceId`. Support of the actual ERC165 interface is automatic and\\n * registering its interface id is not required.\\n *\\n * See {IERC165-supportsInterface}.\\n *\\n * Requirements:\\n *\\n * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).\\n */\\n function _registerInterface(bytes4 interfaceId) internal virtual {\\n require(interfaceId != 0xffffffff, \\\"ERC165: invalid interface id\\\");\\n _supportedInterfaces[interfaceId] = true;\\n }\\n}\\n\",\"keccak256\":\"0x77bf0086774bab931413c3388d3a0f7d44cf6878965b72147f57bb0fbbf394bd\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x447a5f3ddc18419d41ff92b3773fb86471b1db25773e07f877f548918a185bf1\",\"license\":\"MIT\"},\"contracts/GnosisWrapper.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\nimport \\\"@fractal-framework/core-contracts/contracts/ModuleBase.sol\\\";\\r\\nimport \\\"./IGnosisWrapper.sol\\\";\\r\\n\\r\\ncontract GnosisWrapper is ModuleBase {\\r\\n address public gnosisSafe;\\r\\n\\r\\n function initialize(address _accessControl, address _gnosisSafe)\\r\\n public\\r\\n initializer\\r\\n {\\r\\n __initBase(_accessControl, msg.sender, \\\"Wrapper Module\\\");\\r\\n _registerInterface(type(IGnosisWrapper).interfaceId);\\r\\n gnosisSafe = _gnosisSafe;\\r\\n }\\r\\n}\\r\\n\",\"keccak256\":\"0xd2641d9481951a753eea302e81b64ccdf06799b852b166761dcb50ac0f076131\",\"license\":\"Unlicense\"},\"contracts/GnosisWrapperFactory.sol\":{\"content\":\"//SPDX-License-Identifier: Unlicense\\r\\npragma solidity ^0.8.0;\\r\\n\\r\\nimport \\\"@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol\\\";\\r\\nimport \\\"@openzeppelin/contracts/utils/Create2.sol\\\";\\r\\nimport \\\"./GnosisWrapper.sol\\\";\\r\\n\\r\\nimport \\\"@fractal-framework/core-contracts/contracts/ModuleFactoryBase.sol\\\";\\r\\n\\r\\n/// @dev GnosisWrapper Factory used to deploy Gnosis Modules\\r\\ncontract GnosisWrapperFactory is ModuleFactoryBase {\\r\\n event GnosisWrapperCreated(address gnosisSafe);\\r\\n\\r\\n function initialize() external initializer {\\r\\n __initFactoryBase();\\r\\n }\\r\\n\\r\\n /// @dev Creates a GnosisWrapper module\\r\\n /// @param creator The address creating the module\\r\\n /// @param data The array of bytes used to create the module\\r\\n /// @return address[] The array of addresses of the created module\\r\\n function create(address creator, bytes[] calldata data)\\r\\n external\\r\\n override\\r\\n returns (address[] memory)\\r\\n {\\r\\n address[] memory createdContracts = new address[](1);\\r\\n\\r\\n createdContracts[0] = createGnosisWrapper(creator, data);\\r\\n\\r\\n emit GnosisWrapperCreated(createdContracts[0]);\\r\\n\\r\\n return createdContracts;\\r\\n }\\r\\n\\r\\n function createGnosisWrapper(address creator, bytes[] memory data)\\r\\n private\\r\\n returns (address gnosisWrapper)\\r\\n {\\r\\n // Create wrapper\\r\\n gnosisWrapper = Create2.deploy(\\r\\n 0,\\r\\n keccak256(\\r\\n abi.encodePacked(\\r\\n creator,\\r\\n msg.sender,\\r\\n block.chainid,\\r\\n abi.decode(data[3], (bytes32)) // random salt\\r\\n )\\r\\n ),\\r\\n abi.encodePacked(\\r\\n type(ERC1967Proxy).creationCode,\\r\\n abi.encode(address(abi.decode(data[2], (address))), \\\"\\\") // impl address\\r\\n )\\r\\n );\\r\\n\\r\\n GnosisWrapper(gnosisWrapper).initialize(\\r\\n abi.decode(data[0], (address)),\\r\\n abi.decode(data[1], (address))\\r\\n ); // access Control, gnosisSafe\\r\\n }\\r\\n}\\r\\n\",\"keccak256\":\"0x96bf8dbe55472c506bd90bccc3ca6cdc2a8edd8e500333e635dd301417ed2d53\",\"license\":\"Unlicense\"},\"contracts/IGnosisWrapper.sol\":{\"content\":\"pragma solidity ^0.8.0;\\r\\n\\r\\ninterface IGnosisWrapper {\\r\\n function initialize(address _accessControl, address _gnosisSafe) external;\\r\\n function gnosisSafe() external view returns(address);\\r\\n}\\r\\n\",\"keccak256\":\"0xff67355c4beff15b94229e0d77aea18a7a2631b0c3590fe03b3abeaf8d833ac3\"}},\"version\":1}", - "bytecode": "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", - "deployedBytecode": "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", - "devdoc": { - "details": "GnosisWrapper Factory used to deploy Gnosis Modules", - "kind": "dev", - "methods": { - "addVersion(string,string,address)": { - "details": "add a new version to update module users", - "params": { - "_frontendURI": "IPFS hash of the static frontend", - "_impl": "address of the impl", - "_semanticVersion": "semantic version control" - } - }, - "create(address,bytes[])": { - "details": "Creates a GnosisWrapper module", - "params": { - "creator": "The address creating the module", - "data": "The array of bytes used to create the module" - }, - "returns": { - "_0": "address[] The array of addresses of the created module" - } - }, - "owner()": { - "details": "Returns the address of the current owner." - }, - "renounceOwnership()": { - "details": "Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner." - }, - "supportsInterface(bytes4)": { - "details": "See {IERC165-supportsInterface}." - }, - "transferOwnership(address)": { - "details": "Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner." - } - }, - "version": 1 - }, - "userdoc": { - "kind": "user", - "methods": {}, - "version": 1 - }, - "storageLayout": { - "storage": [ - { - "astId": 3018, - "contract": "contracts/GnosisWrapperFactory.sol:GnosisWrapperFactory", - "label": "_owner", - "offset": 0, - "slot": "0", - "type": "t_address" - }, - { - "astId": 2427, - "contract": "contracts/GnosisWrapperFactory.sol:GnosisWrapperFactory", - "label": "_initialized", - "offset": 20, - "slot": "0", - "type": "t_uint8" - }, - { - "astId": 2430, - "contract": "contracts/GnosisWrapperFactory.sol:GnosisWrapperFactory", - "label": "_initializing", - "offset": 21, - "slot": "0", - "type": "t_bool" - }, - { - "astId": 4073, - "contract": "contracts/GnosisWrapperFactory.sol:GnosisWrapperFactory", - "label": "_supportedInterfaces", - "offset": 0, - "slot": "1", - "type": "t_mapping(t_bytes4,t_bool)" - }, - { - "astId": 1513, - "contract": "contracts/GnosisWrapperFactory.sol:GnosisWrapperFactory", - "label": "versionControl", - "offset": 0, - "slot": "2", - "type": "t_array(t_struct(VersionInfo)1930_storage)dyn_storage" - } - ], - "types": { - "t_address": { - "encoding": "inplace", - "label": "address", - "numberOfBytes": "20" - }, - "t_array(t_struct(VersionInfo)1930_storage)dyn_storage": { - "base": "t_struct(VersionInfo)1930_storage", - "encoding": "dynamic_array", - "label": "struct IModuleFactoryBase.VersionInfo[]", - "numberOfBytes": "32" - }, - "t_bool": { - "encoding": "inplace", - "label": "bool", - "numberOfBytes": "1" - }, - "t_bytes4": { - "encoding": "inplace", - "label": "bytes4", - "numberOfBytes": "4" - }, - "t_mapping(t_bytes4,t_bool)": { - "encoding": "mapping", - "key": "t_bytes4", - "label": "mapping(bytes4 => bool)", - "numberOfBytes": "32", - "value": "t_bool" - }, - "t_string_storage": { - "encoding": "bytes", - "label": "string", - "numberOfBytes": "32" - }, - "t_struct(VersionInfo)1930_storage": { - "encoding": "inplace", - "label": "struct IModuleFactoryBase.VersionInfo", - "members": [ - { - "astId": 1925, - "contract": "contracts/GnosisWrapperFactory.sol:GnosisWrapperFactory", - "label": "semanticVersion", - "offset": 0, - "slot": "0", - "type": "t_string_storage" - }, - { - "astId": 1927, - "contract": "contracts/GnosisWrapperFactory.sol:GnosisWrapperFactory", - "label": "frontendURI", - "offset": 0, - "slot": "1", - "type": "t_string_storage" - }, - { - "astId": 1929, - "contract": "contracts/GnosisWrapperFactory.sol:GnosisWrapperFactory", - "label": "impl", - "offset": 0, - "slot": "2", - "type": "t_address" - } - ], - "numberOfBytes": "96" - }, - "t_uint8": { - "encoding": "inplace", - "label": "uint8", - "numberOfBytes": "1" - } - } - } -} \ No newline at end of file diff --git a/deployments/sepolia/solcInputs/32801c180c72a260c0a67f69b3ec7a05.json b/deployments/sepolia/solcInputs/32801c180c72a260c0a67f69b3ec7a05.json deleted file mode 100644 index d6237d80..00000000 --- a/deployments/sepolia/solcInputs/32801c180c72a260c0a67f69b3ec7a05.json +++ /dev/null @@ -1,149 +0,0 @@ -{ - "language": "Solidity", - "sources": { - "contracts/GnosisWrapper.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\nimport \"@fractal-framework/core-contracts/contracts/ModuleBase.sol\";\r\nimport \"./IGnosisWrapper.sol\";\r\n\r\ncontract GnosisWrapper is ModuleBase {\r\n address public gnosisSafe;\r\n\r\n function initialize(address _accessControl, address _gnosisSafe)\r\n public\r\n initializer\r\n {\r\n __initBase(_accessControl, msg.sender, \"Wrapper Module\");\r\n _registerInterface(type(IGnosisWrapper).interfaceId);\r\n gnosisSafe = _gnosisSafe;\r\n }\r\n}\r\n" - }, - "@fractal-framework/core-contracts/contracts/ModuleBase.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\nimport \"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\";\r\nimport \"@openzeppelin/contracts/utils/introspection/ERC165Storage.sol\";\r\nimport \"./interfaces/IModuleBase.sol\";\r\n\r\n/// @notice An abstract contract to be inherited by module contracts\r\nabstract contract ModuleBase is IModuleBase, UUPSUpgradeable, ERC165Storage {\r\n IDAOAccessControl public accessControl;\r\n address public moduleFactory;\r\n string internal _name;\r\n\r\n /// @notice Requires that a function caller has the associated role\r\n modifier authorized() {\r\n if (\r\n !accessControl.actionIsAuthorized(\r\n msg.sender,\r\n address(this),\r\n msg.sig\r\n )\r\n ) {\r\n revert NotAuthorized();\r\n }\r\n _;\r\n }\r\n\r\n /// @notice Function for initializing the contract that can only be called once\r\n /// @param _accessControl The address of the access control contract\r\n /// @param _moduleFactory The address of the factory deploying the module\r\n /// @param __name Human readable string of the module name\r\n function __initBase(address _accessControl, address _moduleFactory, string memory __name)\r\n internal\r\n onlyInitializing\r\n {\r\n accessControl = IDAOAccessControl(_accessControl);\r\n moduleFactory = _moduleFactory;\r\n _name = __name;\r\n __UUPSUpgradeable_init();\r\n _registerInterface(type(IModuleBase).interfaceId);\r\n }\r\n\r\n /// @dev Applies authorized modifier so that an upgrade require the caller to have the correct role\r\n /// @param newImplementation The address of the new implementation contract being upgraded to\r\n function _authorizeUpgrade(address newImplementation)\r\n internal\r\n override\r\n authorized\r\n {}\r\n\r\n /// @notice Returns the module name\r\n /// @return The module name\r\n function name() public view virtual returns (string memory) {\r\n return _name;\r\n }\r\n}\r\n" - }, - "contracts/IGnosisWrapper.sol": { - "content": "pragma solidity ^0.8.0;\r\n\r\ninterface IGnosisWrapper {\r\n function initialize(address _accessControl, address _gnosisSafe) external;\r\n function gnosisSafe() external view returns(address);\r\n}\r\n" - }, - "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (proxy/utils/UUPSUpgradeable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../../interfaces/draft-IERC1822Upgradeable.sol\";\nimport \"../ERC1967/ERC1967UpgradeUpgradeable.sol\";\nimport \"./Initializable.sol\";\n\n/**\n * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an\n * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.\n *\n * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is\n * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing\n * `UUPSUpgradeable` with a custom implementation of upgrades.\n *\n * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.\n *\n * _Available since v4.1._\n */\nabstract contract UUPSUpgradeable is Initializable, IERC1822ProxiableUpgradeable, ERC1967UpgradeUpgradeable {\n function __UUPSUpgradeable_init() internal onlyInitializing {\n }\n\n function __UUPSUpgradeable_init_unchained() internal onlyInitializing {\n }\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment\n address private immutable __self = address(this);\n\n /**\n * @dev Check that the execution is being performed through a delegatecall call and that the execution context is\n * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case\n * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a\n * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to\n * fail.\n */\n modifier onlyProxy() {\n require(address(this) != __self, \"Function must be called through delegatecall\");\n require(_getImplementation() == __self, \"Function must be called through active proxy\");\n _;\n }\n\n /**\n * @dev Check that the execution is not being performed through a delegate call. This allows a function to be\n * callable on the implementing contract but not through proxies.\n */\n modifier notDelegated() {\n require(address(this) == __self, \"UUPSUpgradeable: must not be called through delegatecall\");\n _;\n }\n\n /**\n * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the\n * implementation. It is used to validate that the this implementation remains valid after an upgrade.\n *\n * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\n * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\n * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.\n */\n function proxiableUUID() external view virtual override notDelegated returns (bytes32) {\n return _IMPLEMENTATION_SLOT;\n }\n\n /**\n * @dev Upgrade the implementation of the proxy to `newImplementation`.\n *\n * Calls {_authorizeUpgrade}.\n *\n * Emits an {Upgraded} event.\n */\n function upgradeTo(address newImplementation) external virtual onlyProxy {\n _authorizeUpgrade(newImplementation);\n _upgradeToAndCallUUPS(newImplementation, new bytes(0), false);\n }\n\n /**\n * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call\n * encoded in `data`.\n *\n * Calls {_authorizeUpgrade}.\n *\n * Emits an {Upgraded} event.\n */\n function upgradeToAndCall(address newImplementation, bytes memory data) external payable virtual onlyProxy {\n _authorizeUpgrade(newImplementation);\n _upgradeToAndCallUUPS(newImplementation, data, true);\n }\n\n /**\n * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by\n * {upgradeTo} and {upgradeToAndCall}.\n *\n * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.\n *\n * ```solidity\n * function _authorizeUpgrade(address) internal override onlyOwner {}\n * ```\n */\n function _authorizeUpgrade(address newImplementation) internal virtual;\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[50] private __gap;\n}\n" - }, - "@openzeppelin/contracts/utils/introspection/ERC165Storage.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165Storage.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./ERC165.sol\";\n\n/**\n * @dev Storage based implementation of the {IERC165} interface.\n *\n * Contracts may inherit from this and call {_registerInterface} to declare\n * their support of an interface.\n */\nabstract contract ERC165Storage is ERC165 {\n /**\n * @dev Mapping of interface ids to whether or not it's supported.\n */\n mapping(bytes4 => bool) private _supportedInterfaces;\n\n /**\n * @dev See {IERC165-supportsInterface}.\n */\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n return super.supportsInterface(interfaceId) || _supportedInterfaces[interfaceId];\n }\n\n /**\n * @dev Registers the contract as an implementer of the interface defined by\n * `interfaceId`. Support of the actual ERC165 interface is automatic and\n * registering its interface id is not required.\n *\n * See {IERC165-supportsInterface}.\n *\n * Requirements:\n *\n * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).\n */\n function _registerInterface(bytes4 interfaceId) internal virtual {\n require(interfaceId != 0xffffffff, \"ERC165: invalid interface id\");\n _supportedInterfaces[interfaceId] = true;\n }\n}\n" - }, - "@fractal-framework/core-contracts/contracts/interfaces/IModuleBase.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\nimport \"./IDAOAccessControl.sol\";\r\n\r\ninterface IModuleBase {\r\n error NotAuthorized();\r\n\r\n /// @return IDAOAccessControl The Access control interface\r\n function accessControl() external view returns (IDAOAccessControl);\r\n\r\n /// @return string The string \"Name\"\r\n function name() external view returns (string memory);\r\n}\r\n" - }, - "@openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified\n * proxy whose upgrades are fully controlled by the current implementation.\n */\ninterface IERC1822ProxiableUpgradeable {\n /**\n * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation\n * address.\n *\n * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\n * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\n * function revert if invoked through a proxy.\n */\n function proxiableUUID() external view returns (bytes32);\n}\n" - }, - "@openzeppelin/contracts-upgradeable/proxy/ERC1967/ERC1967UpgradeUpgradeable.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../beacon/IBeaconUpgradeable.sol\";\nimport \"../../interfaces/draft-IERC1822Upgradeable.sol\";\nimport \"../../utils/AddressUpgradeable.sol\";\nimport \"../../utils/StorageSlotUpgradeable.sol\";\nimport \"../utils/Initializable.sol\";\n\n/**\n * @dev This abstract contract provides getters and event emitting update functions for\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.\n *\n * _Available since v4.1._\n *\n * @custom:oz-upgrades-unsafe-allow delegatecall\n */\nabstract contract ERC1967UpgradeUpgradeable is Initializable {\n function __ERC1967Upgrade_init() internal onlyInitializing {\n }\n\n function __ERC1967Upgrade_init_unchained() internal onlyInitializing {\n }\n // This is the keccak-256 hash of \"eip1967.proxy.rollback\" subtracted by 1\n bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;\n\n /**\n * @dev Storage slot with the address of the current implementation.\n * This is the keccak-256 hash of \"eip1967.proxy.implementation\" subtracted by 1, and is\n * validated in the constructor.\n */\n bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n /**\n * @dev Emitted when the implementation is upgraded.\n */\n event Upgraded(address indexed implementation);\n\n /**\n * @dev Returns the current implementation address.\n */\n function _getImplementation() internal view returns (address) {\n return StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n }\n\n /**\n * @dev Stores a new address in the EIP1967 implementation slot.\n */\n function _setImplementation(address newImplementation) private {\n require(AddressUpgradeable.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n }\n\n /**\n * @dev Perform implementation upgrade\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeTo(address newImplementation) internal {\n _setImplementation(newImplementation);\n emit Upgraded(newImplementation);\n }\n\n /**\n * @dev Perform implementation upgrade with additional setup call.\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeToAndCall(\n address newImplementation,\n bytes memory data,\n bool forceCall\n ) internal {\n _upgradeTo(newImplementation);\n if (data.length > 0 || forceCall) {\n _functionDelegateCall(newImplementation, data);\n }\n }\n\n /**\n * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeToAndCallUUPS(\n address newImplementation,\n bytes memory data,\n bool forceCall\n ) internal {\n // Upgrades from old implementations will perform a rollback test. This test requires the new\n // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing\n // this special case will break upgrade paths from old UUPS implementation to new ones.\n if (StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT).value) {\n _setImplementation(newImplementation);\n } else {\n try IERC1822ProxiableUpgradeable(newImplementation).proxiableUUID() returns (bytes32 slot) {\n require(slot == _IMPLEMENTATION_SLOT, \"ERC1967Upgrade: unsupported proxiableUUID\");\n } catch {\n revert(\"ERC1967Upgrade: new implementation is not UUPS\");\n }\n _upgradeToAndCall(newImplementation, data, forceCall);\n }\n }\n\n /**\n * @dev Storage slot with the admin of the contract.\n * This is the keccak-256 hash of \"eip1967.proxy.admin\" subtracted by 1, and is\n * validated in the constructor.\n */\n bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\n\n /**\n * @dev Emitted when the admin account has changed.\n */\n event AdminChanged(address previousAdmin, address newAdmin);\n\n /**\n * @dev Returns the current admin.\n */\n function _getAdmin() internal view returns (address) {\n return StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value;\n }\n\n /**\n * @dev Stores a new address in the EIP1967 admin slot.\n */\n function _setAdmin(address newAdmin) private {\n require(newAdmin != address(0), \"ERC1967: new admin is the zero address\");\n StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value = newAdmin;\n }\n\n /**\n * @dev Changes the admin of the proxy.\n *\n * Emits an {AdminChanged} event.\n */\n function _changeAdmin(address newAdmin) internal {\n emit AdminChanged(_getAdmin(), newAdmin);\n _setAdmin(newAdmin);\n }\n\n /**\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\n */\n bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\n\n /**\n * @dev Emitted when the beacon is upgraded.\n */\n event BeaconUpgraded(address indexed beacon);\n\n /**\n * @dev Returns the current beacon.\n */\n function _getBeacon() internal view returns (address) {\n return StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value;\n }\n\n /**\n * @dev Stores a new beacon in the EIP1967 beacon slot.\n */\n function _setBeacon(address newBeacon) private {\n require(AddressUpgradeable.isContract(newBeacon), \"ERC1967: new beacon is not a contract\");\n require(\n AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()),\n \"ERC1967: beacon implementation is not a contract\"\n );\n StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value = newBeacon;\n }\n\n /**\n * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does\n * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).\n *\n * Emits a {BeaconUpgraded} event.\n */\n function _upgradeBeaconToAndCall(\n address newBeacon,\n bytes memory data,\n bool forceCall\n ) internal {\n _setBeacon(newBeacon);\n emit BeaconUpgraded(newBeacon);\n if (data.length > 0 || forceCall) {\n _functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data);\n }\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function _functionDelegateCall(address target, bytes memory data) private returns (bytes memory) {\n require(AddressUpgradeable.isContract(target), \"Address: delegate call to non-contract\");\n\n // solhint-disable-next-line avoid-low-level-calls\n (bool success, bytes memory returndata) = target.delegatecall(data);\n return AddressUpgradeable.verifyCallResult(success, returndata, \"Address: low-level delegate call failed\");\n }\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[50] private __gap;\n}\n" - }, - "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../../utils/AddressUpgradeable.sol\";\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\n * reused. This mechanism prevents re-execution of each \"step\" but allows the creation of new initialization steps in\n * case an upgrade adds a module that needs to be initialized.\n *\n * For example:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * contract MyToken is ERC20Upgradeable {\n * function initialize() initializer public {\n * __ERC20_init(\"MyToken\", \"MTK\");\n * }\n * }\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\n * function initializeV2() reinitializer(2) public {\n * __ERC20Permit_init(\"MyToken\");\n * }\n * }\n * ```\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n *\n * [CAUTION]\n * ====\n * Avoid leaving a contract uninitialized.\n *\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * /// @custom:oz-upgrades-unsafe-allow constructor\n * constructor() {\n * _disableInitializers();\n * }\n * ```\n * ====\n */\nabstract contract Initializable {\n /**\n * @dev Indicates that the contract has been initialized.\n * @custom:oz-retyped-from bool\n */\n uint8 private _initialized;\n\n /**\n * @dev Indicates that the contract is in the process of being initialized.\n */\n bool private _initializing;\n\n /**\n * @dev Triggered when the contract has been initialized or reinitialized.\n */\n event Initialized(uint8 version);\n\n /**\n * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\n * `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`.\n */\n modifier initializer() {\n bool isTopLevelCall = !_initializing;\n require(\n (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\n \"Initializable: contract is already initialized\"\n );\n _initialized = 1;\n if (isTopLevelCall) {\n _initializing = true;\n }\n _;\n if (isTopLevelCall) {\n _initializing = false;\n emit Initialized(1);\n }\n }\n\n /**\n * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\n * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\n * used to initialize parent contracts.\n *\n * `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original\n * initialization step. This is essential to configure modules that are added through upgrades and that require\n * initialization.\n *\n * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\n * a contract, executing them in the right order is up to the developer or operator.\n */\n modifier reinitializer(uint8 version) {\n require(!_initializing && _initialized < version, \"Initializable: contract is already initialized\");\n _initialized = version;\n _initializing = true;\n _;\n _initializing = false;\n emit Initialized(version);\n }\n\n /**\n * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\n * {initializer} and {reinitializer} modifiers, directly or indirectly.\n */\n modifier onlyInitializing() {\n require(_initializing, \"Initializable: contract is not initializing\");\n _;\n }\n\n /**\n * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\n * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\n * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\n * through proxies.\n */\n function _disableInitializers() internal virtual {\n require(!_initializing, \"Initializable: contract is initializing\");\n if (_initialized < type(uint8).max) {\n _initialized = type(uint8).max;\n emit Initialized(type(uint8).max);\n }\n }\n}\n" - }, - "@openzeppelin/contracts-upgradeable/proxy/beacon/IBeaconUpgradeable.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\n */\ninterface IBeaconUpgradeable {\n /**\n * @dev Must return an address that can be used as a delegate call target.\n *\n * {BeaconProxy} will check that this address is a contract.\n */\n function implementation() external view returns (address);\n}\n" - }, - "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary AddressUpgradeable {\n /**\n * @dev Returns true if `account` is a contract.\n *\n * [IMPORTANT]\n * ====\n * It is unsafe to assume that an address for which this function returns\n * false is an externally-owned account (EOA) and not a contract.\n *\n * Among others, `isContract` will return false for the following\n * types of addresses:\n *\n * - an externally-owned account\n * - a contract in construction\n * - an address where a contract will be created\n * - an address where a contract lived, but was destroyed\n * ====\n *\n * [IMPORTANT]\n * ====\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\n *\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n * constructor.\n * ====\n */\n function isContract(address account) internal view returns (bool) {\n // This method relies on extcodesize/address.code.length, which returns 0\n // for contracts in construction, since the code is only stored at the end\n // of the constructor execution.\n\n return account.code.length > 0;\n }\n\n /**\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n * `recipient`, forwarding all available gas and reverting on errors.\n *\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\n * imposed by `transfer`, making them unable to receive funds via\n * `transfer`. {sendValue} removes this limitation.\n *\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n *\n * IMPORTANT: because control is transferred to `recipient`, care must be\n * taken to not create reentrancy vulnerabilities. Consider using\n * {ReentrancyGuard} or the\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n */\n function sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n (bool success, ) = recipient.call{value: amount}(\"\");\n require(success, \"Address: unable to send value, recipient may have reverted\");\n }\n\n /**\n * @dev Performs a Solidity function call using a low level `call`. A\n * plain `call` is an unsafe replacement for a function call: use this\n * function instead.\n *\n * If `target` reverts with a revert reason, it is bubbled up by this\n * function (like regular Solidity function calls).\n *\n * Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n *\n * Requirements:\n *\n * - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCall(target, data, \"Address: low-level call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n * `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n *\n * Requirements:\n *\n * - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n * with `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value,\n string memory errorMessage\n ) internal returns (bytes memory) {\n require(address(this).balance >= value, \"Address: insufficient balance for call\");\n require(isContract(target), \"Address: call to non-contract\");\n\n (bool success, bytes memory returndata) = target.call{value: value}(data);\n return verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, \"Address: low-level static call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal view returns (bytes memory) {\n require(isContract(target), \"Address: static call to non-contract\");\n\n (bool success, bytes memory returndata) = target.staticcall(data);\n return verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\n * revert reason using the provided one.\n *\n * _Available since v4.3._\n */\n function verifyCallResult(\n bool success,\n bytes memory returndata,\n string memory errorMessage\n ) internal pure returns (bytes memory) {\n if (success) {\n return returndata;\n } else {\n // Look for revert reason and bubble it up if present\n if (returndata.length > 0) {\n // The easiest way to bubble the revert reason is using memory via assembly\n /// @solidity memory-safe-assembly\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(errorMessage);\n }\n }\n }\n}\n" - }, - "@openzeppelin/contracts-upgradeable/utils/StorageSlotUpgradeable.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Library for reading and writing primitive types to specific storage slots.\n *\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\n * This library helps with reading and writing to such slots without the need for inline assembly.\n *\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\n *\n * Example usage to set ERC1967 implementation slot:\n * ```\n * contract ERC1967 {\n * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n *\n * function _getImplementation() internal view returns (address) {\n * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n * }\n *\n * function _setImplementation(address newImplementation) internal {\n * require(Address.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n * }\n * }\n * ```\n *\n * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._\n */\nlibrary StorageSlotUpgradeable {\n struct AddressSlot {\n address value;\n }\n\n struct BooleanSlot {\n bool value;\n }\n\n struct Bytes32Slot {\n bytes32 value;\n }\n\n struct Uint256Slot {\n uint256 value;\n }\n\n /**\n * @dev Returns an `AddressSlot` with member `value` located at `slot`.\n */\n function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\n */\n function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\n */\n function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\n */\n function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n }\n}\n" - }, - "@openzeppelin/contracts/utils/introspection/ERC165.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC165.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n *\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\n */\nabstract contract ERC165 is IERC165 {\n /**\n * @dev See {IERC165-supportsInterface}.\n */\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n return interfaceId == type(IERC165).interfaceId;\n }\n}\n" - }, - "@openzeppelin/contracts/utils/introspection/IERC165.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n /**\n * @dev Returns true if this contract implements the interface defined by\n * `interfaceId`. See the corresponding\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\n * to learn more about how these ids are created.\n *\n * This function call must use less than 30 000 gas.\n */\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n" - }, - "@fractal-framework/core-contracts/contracts/interfaces/IDAOAccessControl.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\ninterface IDAOAccessControl {\r\n struct RoleData {\r\n mapping(address => bool) members;\r\n string adminRole;\r\n }\r\n\r\n error UnequalArrayLengths();\r\n error MissingRole(address account, string role);\r\n error OnlySelfRenounce();\r\n\r\n event ActionRoleAdded(\r\n address target,\r\n string functionDesc,\r\n bytes4 encodedSig,\r\n string role\r\n );\r\n event ActionRoleRemoved(\r\n address target,\r\n string functionDesc,\r\n bytes4 encodedSig,\r\n string role\r\n );\r\n event RoleAdminChanged(\r\n string role,\r\n string previousAdminRole,\r\n string adminRole\r\n );\r\n event RoleGranted(string role, address account, address admin);\r\n event RoleRevoked(string role, address account, address admin);\r\n\r\n /// @notice Initialize DAO action and role permissions\r\n /// @param dao Address to receive DAO role\r\n /// @param roles What permissions are assigned to\r\n /// @param roleAdmins Roles which have the ability to remove or add members\r\n /// @param members Addresses to be granted the specified roles\r\n /// @param targets Contract addresses for actions to be defined on\r\n /// @param functionDescs Function descriptions used to define actions\r\n /// @param actionRoles Roles being granted permission for an action\r\n function initialize(\r\n address dao,\r\n string[] memory roles,\r\n string[] memory roleAdmins,\r\n address[][] memory members,\r\n address[] memory targets,\r\n string[] memory functionDescs,\r\n string[][] memory actionRoles\r\n ) external;\r\n\r\n /// @notice Grants roles to the specified addresses and defines admin roles\r\n /// @notice This function can only be called by the DAO\r\n /// @param roles The roles being granted\r\n /// @param roleAdmins The roles being granted as admins of the specified of roles\r\n /// @param members Addresses being granted each specified role\r\n function daoGrantRolesAndAdmins(\r\n string[] memory roles,\r\n string[] memory roleAdmins,\r\n address[][] memory members\r\n ) external;\r\n\r\n /// @notice Grants roles to the specified addresses\r\n /// @notice This function can only be called by the DAO\r\n /// @param roles The roles being granted\r\n /// @param members Addresses being granted each specified role\r\n function daoGrantRoles(string[] memory roles, address[][] memory members)\r\n external;\r\n\r\n /// @notice Authorizes roles to execute the specified actions\r\n /// @notice This function can only be called by the DAO\r\n /// @param targets The contract addresses that the action functions are implemented on\r\n /// @param functionDescs The function descriptions used to define the actions\r\n /// @param roles Roles being granted permission for an action\r\n function daoAddActionsRoles(\r\n address[] memory targets,\r\n string[] memory functionDescs,\r\n string[][] memory roles\r\n ) external;\r\n\r\n /// @notice Removes autorization for roles to execute the specified actions\r\n /// @notice This function can only be called by the DAO\r\n /// @param targets The contract addresses that the action functions are implemented on\r\n /// @param functionDescs The function description used to define the actions\r\n /// @param roles Roles that action permissions are being removed on\r\n function daoRemoveActionsRoles(\r\n address[] memory targets,\r\n string[] memory functionDescs,\r\n string[][] memory roles\r\n ) external;\r\n\r\n /// @notice Grants a role to the specified address\r\n /// @notice This function can only be called by an admin of the specified role\r\n /// @param role The role being granted\r\n /// @param account The address being granted the specified role\r\n function adminGrantRole(string memory role, address account)\r\n external;\r\n\r\n /// @notice Revokes a role from the specified address\r\n /// @notice This function can only be called by an admin of the specified role\r\n /// @param role The role being revoked\r\n /// @param account The address the role is being revoked from\r\n function adminRevokeRole(string memory role, address account)\r\n external;\r\n\r\n /// @notice Enables an address to remove one of its own roles\r\n /// @notice This function can only be called by the account specified\r\n /// @param role The role being renounced\r\n /// @param account The address renouncing the role\r\n function userRenounceRole(string memory role, address account) external;\r\n\r\n /// @notice Checks if a caller has the permissions to execute the specific action\r\n /// @param caller Address attempting to execute the action\r\n /// @param target Contract address corresponding to the action\r\n /// @param sig The function signature used to define the action\r\n function actionIsAuthorized(\r\n address caller,\r\n address target,\r\n bytes4 sig\r\n ) external view returns (bool isAuthorized);\r\n\r\n /// @notice Returns the roles autorized to execute the specified action\r\n /// @param target Contract address corresponding to the action\r\n /// @param functionDesc The function description used to define the action\r\n function getActionRoles(address target, string memory functionDesc)\r\n external\r\n view\r\n returns (string[] memory roles);\r\n\r\n /// @notice Checks if a specific role is authorized for an action\r\n /// @param role Role that authorization is being checked on\r\n /// @param target Contract address corresponding to the action\r\n /// @param functionDesc Function description used to define the action\r\n /// @return isAuthorized Indicates whether the role is authorized to execute the action\r\n function isRoleAuthorized(\r\n string calldata role,\r\n address target,\r\n string memory functionDesc\r\n ) external view returns (bool isAuthorized);\r\n\r\n /// @notice Returns whether the account has been granted the role\r\n /// @param role Role that authorization is being checked on\r\n /// @param account Address that the role authorization is being check on\r\n /// @return boolean Indicates whether the address has been granted the role\r\n function hasRole(string memory role, address account)\r\n external\r\n view\r\n returns (bool);\r\n\r\n /// @notice Returns the role that is the admin of the specified role\r\n /// @param role Role that the admin role is being returned for\r\n /// @return string The admin role of the specified role\r\n function getRoleAdmin(string memory role)\r\n external\r\n view\r\n returns (string memory);\r\n\r\n /// @return string The string \"DAO_ROLE\"\r\n function DAO_ROLE() external view returns (string memory);\r\n}\r\n" - }, - "contracts/GnosisWrapperFactory.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\nimport \"@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol\";\r\nimport \"@openzeppelin/contracts/utils/Create2.sol\";\r\nimport \"./GnosisWrapper.sol\";\r\n\r\nimport \"@fractal-framework/core-contracts/contracts/ModuleFactoryBase.sol\";\r\n\r\n/// @dev GnosisWrapper Factory used to deploy Gnosis Modules\r\ncontract GnosisWrapperFactory is ModuleFactoryBase {\r\n event GnosisWrapperCreated(address gnosisSafe);\r\n\r\n function initialize() external initializer {\r\n __initFactoryBase();\r\n }\r\n\r\n /// @dev Creates a GnosisWrapper module\r\n /// @param creator The address creating the module\r\n /// @param data The array of bytes used to create the module\r\n /// @return address[] The array of addresses of the created module\r\n function create(address creator, bytes[] calldata data)\r\n external\r\n override\r\n returns (address[] memory)\r\n {\r\n address[] memory createdContracts = new address[](1);\r\n\r\n createdContracts[0] = createGnosisWrapper(creator, data);\r\n\r\n emit GnosisWrapperCreated(createdContracts[0]);\r\n\r\n return createdContracts;\r\n }\r\n\r\n function createGnosisWrapper(address creator, bytes[] memory data)\r\n private\r\n returns (address gnosisWrapper)\r\n {\r\n // Create wrapper\r\n gnosisWrapper = Create2.deploy(\r\n 0,\r\n keccak256(\r\n abi.encodePacked(\r\n creator,\r\n msg.sender,\r\n block.chainid,\r\n abi.decode(data[3], (bytes32)) // random salt\r\n )\r\n ),\r\n abi.encodePacked(\r\n type(ERC1967Proxy).creationCode,\r\n abi.encode(address(abi.decode(data[2], (address))), \"\") // impl address\r\n )\r\n );\r\n\r\n GnosisWrapper(gnosisWrapper).initialize(\r\n abi.decode(data[0], (address)),\r\n abi.decode(data[1], (address))\r\n ); // access Control, gnosisSafe\r\n }\r\n}\r\n" - }, - "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (proxy/ERC1967/ERC1967Proxy.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../Proxy.sol\";\nimport \"./ERC1967Upgrade.sol\";\n\n/**\n * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an\n * implementation address that can be changed. This address is stored in storage in the location specified by\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the\n * implementation behind the proxy.\n */\ncontract ERC1967Proxy is Proxy, ERC1967Upgrade {\n /**\n * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.\n *\n * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded\n * function call, and allows initializing the storage of the proxy like a Solidity constructor.\n */\n constructor(address _logic, bytes memory _data) payable {\n _upgradeToAndCall(_logic, _data, false);\n }\n\n /**\n * @dev Returns the current implementation address.\n */\n function _implementation() internal view virtual override returns (address impl) {\n return ERC1967Upgrade._getImplementation();\n }\n}\n" - }, - "@openzeppelin/contracts/utils/Create2.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Create2.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Helper to make usage of the `CREATE2` EVM opcode easier and safer.\n * `CREATE2` can be used to compute in advance the address where a smart\n * contract will be deployed, which allows for interesting new mechanisms known\n * as 'counterfactual interactions'.\n *\n * See the https://eips.ethereum.org/EIPS/eip-1014#motivation[EIP] for more\n * information.\n */\nlibrary Create2 {\n /**\n * @dev Deploys a contract using `CREATE2`. The address where the contract\n * will be deployed can be known in advance via {computeAddress}.\n *\n * The bytecode for a contract can be obtained from Solidity with\n * `type(contractName).creationCode`.\n *\n * Requirements:\n *\n * - `bytecode` must not be empty.\n * - `salt` must have not been used for `bytecode` already.\n * - the factory must have a balance of at least `amount`.\n * - if `amount` is non-zero, `bytecode` must have a `payable` constructor.\n */\n function deploy(\n uint256 amount,\n bytes32 salt,\n bytes memory bytecode\n ) internal returns (address) {\n address addr;\n require(address(this).balance >= amount, \"Create2: insufficient balance\");\n require(bytecode.length != 0, \"Create2: bytecode length is zero\");\n /// @solidity memory-safe-assembly\n assembly {\n addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt)\n }\n require(addr != address(0), \"Create2: Failed on deploy\");\n return addr;\n }\n\n /**\n * @dev Returns the address where a contract will be stored if deployed via {deploy}. Any change in the\n * `bytecodeHash` or `salt` will result in a new destination address.\n */\n function computeAddress(bytes32 salt, bytes32 bytecodeHash) internal view returns (address) {\n return computeAddress(salt, bytecodeHash, address(this));\n }\n\n /**\n * @dev Returns the address where a contract will be stored if deployed via {deploy} from a contract located at\n * `deployer`. If `deployer` is this contract's address, returns the same value as {computeAddress}.\n */\n function computeAddress(\n bytes32 salt,\n bytes32 bytecodeHash,\n address deployer\n ) internal pure returns (address) {\n bytes32 _data = keccak256(abi.encodePacked(bytes1(0xff), deployer, salt, bytecodeHash));\n return address(uint160(uint256(_data)));\n }\n}\n" - }, - "@fractal-framework/core-contracts/contracts/ModuleFactoryBase.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\r\nimport \"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\";\r\nimport \"@openzeppelin/contracts/utils/introspection/ERC165Storage.sol\";\r\nimport \"./interfaces/IModuleFactoryBase.sol\";\r\n\r\n/// @notice An abstract contract to be inherited by module contracts\r\nabstract contract ModuleFactoryBase is\r\n IModuleFactoryBase,\r\n Ownable,\r\n Initializable,\r\n ERC165Storage\r\n{\r\n VersionInfo[] public versionControl;\r\n\r\n /// @dev add a new version to update module users\r\n /// @param _semanticVersion semantic version control\r\n /// @param _frontendURI IPFS hash of the static frontend\r\n /// @param _impl address of the impl\r\n function addVersion(\r\n string calldata _semanticVersion,\r\n string calldata _frontendURI,\r\n address _impl\r\n ) external onlyOwner {\r\n versionControl.push(VersionInfo(_semanticVersion, _frontendURI, _impl));\r\n emit VersionCreated(_semanticVersion, _frontendURI, _impl);\r\n }\r\n\r\n /// @dev Creates a module\r\n /// @param creator The address creating the module\r\n /// @param data The array of bytes used to create the module\r\n /// @return address[] Array of the created module addresses\r\n function create(address creator, bytes[] calldata data)\r\n external\r\n virtual\r\n returns (address[] memory);\r\n\r\n /// @notice Function for initializing the contract that can only be called once\r\n function __initFactoryBase() internal onlyInitializing {\r\n _registerInterface(type(IModuleFactoryBase).interfaceId);\r\n }\r\n}\r\n" - }, - "@openzeppelin/contracts/proxy/Proxy.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\n * be specified by overriding the virtual {_implementation} function.\n *\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\n * different contract through the {_delegate} function.\n *\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\n */\nabstract contract Proxy {\n /**\n * @dev Delegates the current call to `implementation`.\n *\n * This function does not return to its internal call site, it will return directly to the external caller.\n */\n function _delegate(address implementation) internal virtual {\n assembly {\n // Copy msg.data. We take full control of memory in this inline assembly\n // block because it will not return to Solidity code. We overwrite the\n // Solidity scratch pad at memory position 0.\n calldatacopy(0, 0, calldatasize())\n\n // Call the implementation.\n // out and outsize are 0 because we don't know the size yet.\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\n\n // Copy the returned data.\n returndatacopy(0, 0, returndatasize())\n\n switch result\n // delegatecall returns 0 on error.\n case 0 {\n revert(0, returndatasize())\n }\n default {\n return(0, returndatasize())\n }\n }\n }\n\n /**\n * @dev This is a virtual function that should be overridden so it returns the address to which the fallback function\n * and {_fallback} should delegate.\n */\n function _implementation() internal view virtual returns (address);\n\n /**\n * @dev Delegates the current call to the address returned by `_implementation()`.\n *\n * This function does not return to its internal call site, it will return directly to the external caller.\n */\n function _fallback() internal virtual {\n _beforeFallback();\n _delegate(_implementation());\n }\n\n /**\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\n * function in the contract matches the call data.\n */\n fallback() external payable virtual {\n _fallback();\n }\n\n /**\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\n * is empty.\n */\n receive() external payable virtual {\n _fallback();\n }\n\n /**\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\n * call, or as part of the Solidity `fallback` or `receive` functions.\n *\n * If overridden should call `super._beforeFallback()`.\n */\n function _beforeFallback() internal virtual {}\n}\n" - }, - "@openzeppelin/contracts/proxy/ERC1967/ERC1967Upgrade.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../beacon/IBeacon.sol\";\nimport \"../../interfaces/draft-IERC1822.sol\";\nimport \"../../utils/Address.sol\";\nimport \"../../utils/StorageSlot.sol\";\n\n/**\n * @dev This abstract contract provides getters and event emitting update functions for\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.\n *\n * _Available since v4.1._\n *\n * @custom:oz-upgrades-unsafe-allow delegatecall\n */\nabstract contract ERC1967Upgrade {\n // This is the keccak-256 hash of \"eip1967.proxy.rollback\" subtracted by 1\n bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;\n\n /**\n * @dev Storage slot with the address of the current implementation.\n * This is the keccak-256 hash of \"eip1967.proxy.implementation\" subtracted by 1, and is\n * validated in the constructor.\n */\n bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n /**\n * @dev Emitted when the implementation is upgraded.\n */\n event Upgraded(address indexed implementation);\n\n /**\n * @dev Returns the current implementation address.\n */\n function _getImplementation() internal view returns (address) {\n return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n }\n\n /**\n * @dev Stores a new address in the EIP1967 implementation slot.\n */\n function _setImplementation(address newImplementation) private {\n require(Address.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n }\n\n /**\n * @dev Perform implementation upgrade\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeTo(address newImplementation) internal {\n _setImplementation(newImplementation);\n emit Upgraded(newImplementation);\n }\n\n /**\n * @dev Perform implementation upgrade with additional setup call.\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeToAndCall(\n address newImplementation,\n bytes memory data,\n bool forceCall\n ) internal {\n _upgradeTo(newImplementation);\n if (data.length > 0 || forceCall) {\n Address.functionDelegateCall(newImplementation, data);\n }\n }\n\n /**\n * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.\n *\n * Emits an {Upgraded} event.\n */\n function _upgradeToAndCallUUPS(\n address newImplementation,\n bytes memory data,\n bool forceCall\n ) internal {\n // Upgrades from old implementations will perform a rollback test. This test requires the new\n // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing\n // this special case will break upgrade paths from old UUPS implementation to new ones.\n if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {\n _setImplementation(newImplementation);\n } else {\n try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {\n require(slot == _IMPLEMENTATION_SLOT, \"ERC1967Upgrade: unsupported proxiableUUID\");\n } catch {\n revert(\"ERC1967Upgrade: new implementation is not UUPS\");\n }\n _upgradeToAndCall(newImplementation, data, forceCall);\n }\n }\n\n /**\n * @dev Storage slot with the admin of the contract.\n * This is the keccak-256 hash of \"eip1967.proxy.admin\" subtracted by 1, and is\n * validated in the constructor.\n */\n bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\n\n /**\n * @dev Emitted when the admin account has changed.\n */\n event AdminChanged(address previousAdmin, address newAdmin);\n\n /**\n * @dev Returns the current admin.\n */\n function _getAdmin() internal view returns (address) {\n return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;\n }\n\n /**\n * @dev Stores a new address in the EIP1967 admin slot.\n */\n function _setAdmin(address newAdmin) private {\n require(newAdmin != address(0), \"ERC1967: new admin is the zero address\");\n StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;\n }\n\n /**\n * @dev Changes the admin of the proxy.\n *\n * Emits an {AdminChanged} event.\n */\n function _changeAdmin(address newAdmin) internal {\n emit AdminChanged(_getAdmin(), newAdmin);\n _setAdmin(newAdmin);\n }\n\n /**\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\n */\n bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\n\n /**\n * @dev Emitted when the beacon is upgraded.\n */\n event BeaconUpgraded(address indexed beacon);\n\n /**\n * @dev Returns the current beacon.\n */\n function _getBeacon() internal view returns (address) {\n return StorageSlot.getAddressSlot(_BEACON_SLOT).value;\n }\n\n /**\n * @dev Stores a new beacon in the EIP1967 beacon slot.\n */\n function _setBeacon(address newBeacon) private {\n require(Address.isContract(newBeacon), \"ERC1967: new beacon is not a contract\");\n require(\n Address.isContract(IBeacon(newBeacon).implementation()),\n \"ERC1967: beacon implementation is not a contract\"\n );\n StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;\n }\n\n /**\n * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does\n * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).\n *\n * Emits a {BeaconUpgraded} event.\n */\n function _upgradeBeaconToAndCall(\n address newBeacon,\n bytes memory data,\n bool forceCall\n ) internal {\n _setBeacon(newBeacon);\n emit BeaconUpgraded(newBeacon);\n if (data.length > 0 || forceCall) {\n Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);\n }\n }\n}\n" - }, - "@openzeppelin/contracts/proxy/beacon/IBeacon.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\n */\ninterface IBeacon {\n /**\n * @dev Must return an address that can be used as a delegate call target.\n *\n * {BeaconProxy} will check that this address is a contract.\n */\n function implementation() external view returns (address);\n}\n" - }, - "@openzeppelin/contracts/interfaces/draft-IERC1822.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified\n * proxy whose upgrades are fully controlled by the current implementation.\n */\ninterface IERC1822Proxiable {\n /**\n * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation\n * address.\n *\n * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\n * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\n * function revert if invoked through a proxy.\n */\n function proxiableUUID() external view returns (bytes32);\n}\n" - }, - "@openzeppelin/contracts/utils/Address.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n /**\n * @dev Returns true if `account` is a contract.\n *\n * [IMPORTANT]\n * ====\n * It is unsafe to assume that an address for which this function returns\n * false is an externally-owned account (EOA) and not a contract.\n *\n * Among others, `isContract` will return false for the following\n * types of addresses:\n *\n * - an externally-owned account\n * - a contract in construction\n * - an address where a contract will be created\n * - an address where a contract lived, but was destroyed\n * ====\n *\n * [IMPORTANT]\n * ====\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\n *\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n * constructor.\n * ====\n */\n function isContract(address account) internal view returns (bool) {\n // This method relies on extcodesize/address.code.length, which returns 0\n // for contracts in construction, since the code is only stored at the end\n // of the constructor execution.\n\n return account.code.length > 0;\n }\n\n /**\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n * `recipient`, forwarding all available gas and reverting on errors.\n *\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\n * imposed by `transfer`, making them unable to receive funds via\n * `transfer`. {sendValue} removes this limitation.\n *\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n *\n * IMPORTANT: because control is transferred to `recipient`, care must be\n * taken to not create reentrancy vulnerabilities. Consider using\n * {ReentrancyGuard} or the\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n */\n function sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n (bool success, ) = recipient.call{value: amount}(\"\");\n require(success, \"Address: unable to send value, recipient may have reverted\");\n }\n\n /**\n * @dev Performs a Solidity function call using a low level `call`. A\n * plain `call` is an unsafe replacement for a function call: use this\n * function instead.\n *\n * If `target` reverts with a revert reason, it is bubbled up by this\n * function (like regular Solidity function calls).\n *\n * Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n *\n * Requirements:\n *\n * - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCall(target, data, \"Address: low-level call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n * `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n *\n * Requirements:\n *\n * - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n * with `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value,\n string memory errorMessage\n ) internal returns (bytes memory) {\n require(address(this).balance >= value, \"Address: insufficient balance for call\");\n require(isContract(target), \"Address: call to non-contract\");\n\n (bool success, bytes memory returndata) = target.call{value: value}(data);\n return verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, \"Address: low-level static call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal view returns (bytes memory) {\n require(isContract(target), \"Address: static call to non-contract\");\n\n (bool success, bytes memory returndata) = target.staticcall(data);\n return verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n require(isContract(target), \"Address: delegate call to non-contract\");\n\n (bool success, bytes memory returndata) = target.delegatecall(data);\n return verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\n * revert reason using the provided one.\n *\n * _Available since v4.3._\n */\n function verifyCallResult(\n bool success,\n bytes memory returndata,\n string memory errorMessage\n ) internal pure returns (bytes memory) {\n if (success) {\n return returndata;\n } else {\n // Look for revert reason and bubble it up if present\n if (returndata.length > 0) {\n // The easiest way to bubble the revert reason is using memory via assembly\n /// @solidity memory-safe-assembly\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(errorMessage);\n }\n }\n }\n}\n" - }, - "@openzeppelin/contracts/utils/StorageSlot.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Library for reading and writing primitive types to specific storage slots.\n *\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\n * This library helps with reading and writing to such slots without the need for inline assembly.\n *\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\n *\n * Example usage to set ERC1967 implementation slot:\n * ```\n * contract ERC1967 {\n * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n *\n * function _getImplementation() internal view returns (address) {\n * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n * }\n *\n * function _setImplementation(address newImplementation) internal {\n * require(Address.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n * }\n * }\n * ```\n *\n * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._\n */\nlibrary StorageSlot {\n struct AddressSlot {\n address value;\n }\n\n struct BooleanSlot {\n bool value;\n }\n\n struct Bytes32Slot {\n bytes32 value;\n }\n\n struct Uint256Slot {\n uint256 value;\n }\n\n /**\n * @dev Returns an `AddressSlot` with member `value` located at `slot`.\n */\n function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\n */\n function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\n */\n function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\n */\n function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n /// @solidity memory-safe-assembly\n assembly {\n r.slot := slot\n }\n }\n}\n" - }, - "@openzeppelin/contracts/access/Ownable.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n address private _owner;\n\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n /**\n * @dev Initializes the contract setting the deployer as the initial owner.\n */\n constructor() {\n _transferOwnership(_msgSender());\n }\n\n /**\n * @dev Throws if called by any account other than the owner.\n */\n modifier onlyOwner() {\n _checkOwner();\n _;\n }\n\n /**\n * @dev Returns the address of the current owner.\n */\n function owner() public view virtual returns (address) {\n return _owner;\n }\n\n /**\n * @dev Throws if the sender is not the owner.\n */\n function _checkOwner() internal view virtual {\n require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n }\n\n /**\n * @dev Leaves the contract without owner. It will not be possible to call\n * `onlyOwner` functions anymore. Can only be called by the current owner.\n *\n * NOTE: Renouncing ownership will leave the contract without an owner,\n * thereby removing any functionality that is only available to the owner.\n */\n function renounceOwnership() public virtual onlyOwner {\n _transferOwnership(address(0));\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Can only be called by the current owner.\n */\n function transferOwnership(address newOwner) public virtual onlyOwner {\n require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n _transferOwnership(newOwner);\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Internal function without access restriction.\n */\n function _transferOwnership(address newOwner) internal virtual {\n address oldOwner = _owner;\n _owner = newOwner;\n emit OwnershipTransferred(oldOwner, newOwner);\n }\n}\n" - }, - "@fractal-framework/core-contracts/contracts/interfaces/IModuleFactoryBase.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\n/// @dev The interface to be inherited by Fractal module factories\r\ninterface IModuleFactoryBase {\r\n event VersionCreated(\r\n string semanticVersion,\r\n string frontendURI,\r\n address impl\r\n );\r\n struct VersionInfo {\r\n string semanticVersion;\r\n string frontendURI;\r\n address impl;\r\n }\r\n\r\n /// @dev add a new version to update module users\r\n /// @param _semanticVersion semantic version control\r\n /// @param _frontendURI IPFS hash of the static frontend\r\n /// @param _impl address of the impl\r\n function addVersion(\r\n string calldata _semanticVersion,\r\n string calldata _frontendURI,\r\n address _impl\r\n ) external;\r\n\r\n /// @dev Creates a module\r\n /// @param creator The address creating the module\r\n /// @param data The array of bytes used to create the module\r\n /// @return address[] Array of the created module addresses\r\n function create(address creator, bytes[] calldata data)\r\n external\r\n returns (address[] memory);\r\n}\r\n" - }, - "@openzeppelin/contracts/utils/Context.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n function _msgSender() internal view virtual returns (address) {\n return msg.sender;\n }\n\n function _msgData() internal view virtual returns (bytes calldata) {\n return msg.data;\n }\n}\n" - }, - "contracts/mocks/MetaFactory.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\nimport \"@openzeppelin/contracts/utils/introspection/ERC165.sol\";\r\nimport \"@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol\";\r\nimport \"@openzeppelin/contracts/utils/Address.sol\";\r\nimport \"@openzeppelin/contracts-upgradeable/governance/utils/IVotesUpgradeable.sol\";\r\nimport \"@openzeppelin/contracts/utils/Address.sol\";\r\n\r\nimport \"./interfaces/IMetaFactory.sol\";\r\nimport \"@fractal-framework/core-contracts/contracts/interfaces/IDAO.sol\";\r\nimport \"@fractal-framework/core-contracts/contracts/interfaces/IModuleFactoryBase.sol\";\r\n\r\n/// @notice A factory contract for deploying DAOs along with any desired modules within one transaction\r\n/// @dev For the Metafactory to be able to call the execute function on the created DAO, it needs to be given\r\n/// @dev a role that has permissions to call this function. It is critical to have the MetaFactory then revoke\r\n/// @dev this role within the same transaction, so that the MetaFactory cannot be used to perform arbitrary\r\n/// @dev execution calls on the DAO in the future.\r\ncontract MetaFactory is IMetaFactory, ERC165 {\r\n /// @notice Creates a DAO, Access Control, and any modules specified\r\n /// @param daoFactory The address of the DAO factory\r\n /// @param createDAOParams The struct of parameters used for creating the DAO and Access Control contracts\r\n /// @param moduleFactories Array of addresses of the module factories to call\r\n /// @param moduleFactoriesBytes Array of array of bytes to pass to module factory calls\r\n /// @param targets An array of addresses to target for the function calls\r\n /// @param values An array of ether values to send with the function calls\r\n /// @param calldatas An array of bytes defining the function calls\r\n function createDAOAndExecute(\r\n address daoFactory,\r\n IDAOFactory.CreateDAOParams memory createDAOParams,\r\n address[] calldata moduleFactories,\r\n bytes[][] calldata moduleFactoriesBytes,\r\n address[] calldata targets,\r\n uint256[] calldata values,\r\n bytes[] calldata calldatas\r\n ) external {\r\n createDAO(daoFactory, createDAOParams);\r\n createModules(moduleFactories, moduleFactoriesBytes);\r\n execute(targets, values, calldatas);\r\n }\r\n\r\n /// @notice A function for creating the DAO and Access Control contracts\r\n /// @param daoFactory The address of the DAO factory\r\n /// @param createDAOParams The struct of parameters used for creating the DAO and Access Control contracts\r\n function createDAO(\r\n address daoFactory,\r\n IDAOFactory.CreateDAOParams memory createDAOParams\r\n ) internal {\r\n (address dao, address accessControl) = IDAOFactory(daoFactory)\r\n .createDAO(msg.sender, createDAOParams);\r\n\r\n emit DAOCreated(dao, accessControl, msg.sender);\r\n }\r\n\r\n function createModules(\r\n address[] calldata moduleFactories,\r\n bytes[][] calldata moduleFactoriesBytes\r\n ) internal {\r\n if (moduleFactories.length != moduleFactoriesBytes.length)\r\n revert UnequalArrayLengths();\r\n\r\n for (uint256 i; i < moduleFactories.length; i++) {\r\n IModuleFactoryBase(moduleFactories[i]).create(\r\n msg.sender,\r\n moduleFactoriesBytes[i]\r\n );\r\n }\r\n }\r\n\r\n /// @notice A function for executing function calls to deploy an MVD, modules, and initialize them\r\n /// @param targets An array of addresses to target for the function calls\r\n /// @param values An array of ether values to send with the function calls\r\n /// @param calldatas An array of bytes defining the function calls\r\n function execute(\r\n address[] calldata targets,\r\n uint256[] calldata values,\r\n bytes[] calldata calldatas\r\n ) internal {\r\n if (\r\n targets.length != values.length ||\r\n targets.length != calldatas.length\r\n ) revert UnequalArrayLengths();\r\n string\r\n memory errorMessage = \"MetaFactory: call reverted without message\";\r\n uint256 targetlength = targets.length;\r\n for (uint256 i = 0; i < targetlength; ) {\r\n (bool success, bytes memory returndata) = targets[i].call{\r\n value: values[i]\r\n }(calldatas[i]);\r\n Address.verifyCallResult(success, returndata, errorMessage);\r\n unchecked {\r\n i++;\r\n }\r\n }\r\n emit Executed(targets, values, calldatas);\r\n }\r\n\r\n /// @notice Returns whether a given interface ID is supported\r\n /// @param interfaceId An interface ID bytes4 as defined by ERC-165\r\n /// @return bool Indicates whether the interface is supported\r\n function supportsInterface(bytes4 interfaceId)\r\n public\r\n view\r\n virtual\r\n override\r\n returns (bool)\r\n {\r\n return\r\n interfaceId == type(IMetaFactory).interfaceId ||\r\n super.supportsInterface(interfaceId);\r\n }\r\n}\r\n" - }, - "@openzeppelin/contracts-upgradeable/governance/utils/IVotesUpgradeable.sol": { - "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (governance/utils/IVotes.sol)\npragma solidity ^0.8.0;\n\n/**\n * @dev Common interface for {ERC20Votes}, {ERC721Votes}, and other {Votes}-enabled contracts.\n *\n * _Available since v4.5._\n */\ninterface IVotesUpgradeable {\n /**\n * @dev Emitted when an account changes their delegate.\n */\n event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);\n\n /**\n * @dev Emitted when a token transfer or delegate change results in changes to a delegate's number of votes.\n */\n event DelegateVotesChanged(address indexed delegate, uint256 previousBalance, uint256 newBalance);\n\n /**\n * @dev Returns the current amount of votes that `account` has.\n */\n function getVotes(address account) external view returns (uint256);\n\n /**\n * @dev Returns the amount of votes that `account` had at the end of a past block (`blockNumber`).\n */\n function getPastVotes(address account, uint256 blockNumber) external view returns (uint256);\n\n /**\n * @dev Returns the total supply of votes available at the end of a past block (`blockNumber`).\n *\n * NOTE: This value is the sum of all available votes, which is not necessarily the sum of all delegated votes.\n * Votes that have not been delegated are still part of total supply, even though they would not participate in a\n * vote.\n */\n function getPastTotalSupply(uint256 blockNumber) external view returns (uint256);\n\n /**\n * @dev Returns the delegate that `account` has chosen.\n */\n function delegates(address account) external view returns (address);\n\n /**\n * @dev Delegates votes from the sender to `delegatee`.\n */\n function delegate(address delegatee) external;\n\n /**\n * @dev Delegates votes from signer to `delegatee`.\n */\n function delegateBySig(\n address delegatee,\n uint256 nonce,\n uint256 expiry,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) external;\n}\n" - }, - "contracts/mocks/interfaces/IMetaFactory.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\nimport \"@fractal-framework/core-contracts/contracts/interfaces/IDAOFactory.sol\";\r\n\r\ninterface IMetaFactory {\r\n event DAOCreated(address indexed daoAddress, address indexed accessControl, address indexed creator);\r\n event Executed(address[] targets, uint256[] values, bytes[] calldatas);\r\n\r\n error UnequalArrayLengths();\r\n\r\n /// @notice Creates a DAO, Access Control, and any modules specified\r\n /// @param daoFactory The address of the DAO factory\r\n /// @param createDAOParams The struct of parameters used for creating the DAO and Access Control contracts\r\n /// @param moduleFactories Array of addresses of the module factories to call\r\n /// @param moduleFactoriesBytes Array of array of bytes to pass to module factory calls\r\n /// @param targets An array of addresses to target for the function calls\r\n /// @param values An array of ether values to send with the function calls\r\n /// @param calldatas An array of bytes defining the function calls\r\n function createDAOAndExecute(\r\n address daoFactory,\r\n IDAOFactory.CreateDAOParams memory createDAOParams,\r\n address[] calldata moduleFactories,\r\n bytes[][] calldata moduleFactoriesBytes,\r\n address[] calldata targets,\r\n uint256[] calldata values,\r\n bytes[] calldata calldatas\r\n ) external;\r\n}\r\n" - }, - "@fractal-framework/core-contracts/contracts/interfaces/IDAO.sol": { - "content": "import \"./IModuleBase.sol\";\r\n\r\n//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\ninterface IDAO {\r\n error Unauthorized(bytes32 role, address account);\r\n error UnequalArrayLengths();\r\n\r\n event Executed(address[] targets, uint256[] values, bytes[] calldatas);\r\n\r\n /// @notice Function for initializing the Dao\r\n /// @param _accessControl The address of the access control contract\r\n /// @param _moduleFactory The address of the module factory\r\n /// @param _name Name of the Dao\r\n function initialize(address _accessControl, address _moduleFactory, string calldata _name) external;\r\n\r\n /// @notice A function for executing function calls from the DAO\r\n /// @param targets An array of addresses to target for the function calls\r\n /// @param values An array of ether values to send with the function calls\r\n /// @param calldatas An array of bytes defining the function calls\r\n function execute(\r\n address[] calldata targets,\r\n uint256[] calldata values,\r\n bytes[] calldata calldatas\r\n ) external;\r\n}\r\n" - }, - "@fractal-framework/core-contracts/contracts/interfaces/IDAOFactory.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\ninterface IDAOFactory {\r\n struct CreateDAOParams {\r\n address daoImplementation;\r\n address accessControlImplementation;\r\n bytes32 salt;\r\n string daoName;\r\n string[] roles;\r\n string[] rolesAdmins;\r\n address[][] members;\r\n string[] daoFunctionDescs;\r\n string[][] daoActionRoles;\r\n }\r\n\r\n event DAOCreated(address indexed daoAddress, address accessControl, address indexed sender, address indexed creator);\r\n\r\n /// @notice Creates a DAO with an access control contract\r\n /// @param creator Address of the Dao Creator\r\n /// @param createDAOParams Struct of all the parameters required to create a DAO\r\n /// @return dao The address of the deployed DAO proxy contract\r\n /// @return accessControl The address of the deployed access control proxy contract\r\n function createDAO(address creator, CreateDAOParams calldata createDAOParams)\r\n external\r\n returns (address, address);\r\n}\r\n" - }, - "@fractal-framework/core-contracts/contracts/DAOFactory.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\nimport \"@openzeppelin/contracts/utils/introspection/ERC165Storage.sol\";\r\nimport \"@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol\";\r\nimport \"@openzeppelin/contracts/utils/Create2.sol\";\r\n\r\nimport \"./interfaces/IDAOFactory.sol\";\r\nimport \"./interfaces/IDAOAccessControl.sol\";\r\nimport \"./interfaces/IDAO.sol\";\r\n\r\n/// @notice A factory contract for deploying DAOs with an access control contract\r\ncontract DAOFactory is IDAOFactory, ERC165Storage {\r\n constructor() {\r\n _registerInterface(type(IDAOFactory).interfaceId);\r\n }\r\n\r\n /// @notice Creates a DAO with an access control contract\r\n /// @param creator Address of the Dao Creator\r\n /// @param createDAOParams Struct of all the parameters required to create a DAO\r\n /// @return dao The address of the deployed DAO proxy contract\r\n /// @return accessControl The address of the deployed access control proxy contract\r\n function createDAO(\r\n address creator,\r\n CreateDAOParams calldata createDAOParams\r\n ) external returns (address dao, address accessControl) {\r\n dao = _createDAO(creator, createDAOParams);\r\n accessControl = _createAccessControl(creator, createDAOParams);\r\n\r\n address[] memory targets = new address[](\r\n createDAOParams.daoFunctionDescs.length\r\n );\r\n\r\n for (uint256 i; i < createDAOParams.daoFunctionDescs.length; ) {\r\n targets[i] = dao;\r\n unchecked {\r\n i++;\r\n }\r\n }\r\n\r\n IDAO(dao).initialize(\r\n accessControl,\r\n address(this),\r\n createDAOParams.daoName\r\n );\r\n IDAOAccessControl(accessControl).initialize(\r\n dao,\r\n createDAOParams.roles,\r\n createDAOParams.rolesAdmins,\r\n createDAOParams.members,\r\n targets,\r\n createDAOParams.daoFunctionDescs,\r\n createDAOParams.daoActionRoles\r\n );\r\n\r\n emit DAOCreated(dao, accessControl, msg.sender, creator);\r\n }\r\n\r\n /// @notice Creates a DAO contract\r\n /// @param creator Address of the Dao Creator\r\n /// @param createDAOParams Struct of all the parameters required to create a DAO\r\n /// @return _dao The address of the deployed DAO proxy contract\r\n function _createDAO(address creator, CreateDAOParams calldata createDAOParams)\r\n internal\r\n returns (address _dao)\r\n {\r\n _dao = Create2.deploy(\r\n 0,\r\n keccak256(abi.encodePacked(creator, msg.sender, block.chainid, createDAOParams.salt)),\r\n abi.encodePacked(\r\n type(ERC1967Proxy).creationCode,\r\n abi.encode(createDAOParams.daoImplementation, \"\")\r\n )\r\n );\r\n }\r\n\r\n /// @notice Creates a an access control contract\r\n /// @param creator Address of the Dao Creator\r\n /// @param createDAOParams Struct of all the parameters required to create a DAO\r\n /// @return _accessControl The address of the deployed access control proxy contract\r\n function _createAccessControl(address creator, CreateDAOParams memory createDAOParams)\r\n internal\r\n returns (address _accessControl)\r\n {\r\n _accessControl = Create2.deploy(\r\n 0,\r\n keccak256(abi.encodePacked(creator, msg.sender, block.chainid, createDAOParams.salt)),\r\n abi.encodePacked(\r\n type(ERC1967Proxy).creationCode,\r\n abi.encode(createDAOParams.accessControlImplementation, \"\")\r\n )\r\n );\r\n }\r\n}\r\n" - }, - "@fractal-framework/core-contracts/contracts/DAOAccessControl.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\nimport \"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\";\r\nimport \"@openzeppelin/contracts/utils/introspection/ERC165Storage.sol\";\r\n\r\nimport \"./interfaces/IDAOAccessControl.sol\";\r\n\r\n/// @title DAO Access Control\r\n/// @notice Use this contract for managing DAO role based permissions\r\ncontract DAOAccessControl is IDAOAccessControl, ERC165Storage, UUPSUpgradeable {\r\n string public constant DAO_ROLE = \"DAO_ROLE\";\r\n string public constant OPEN_ROLE = \"OPEN_ROLE\";\r\n\r\n mapping(string => RoleData) private _roles;\r\n mapping(address => mapping(bytes4 => string[])) private _actionsToRoles;\r\n\r\n /// @notice Modifier that checks that an account has a specific role. Reverts\r\n /// with a standardized message including the required role.\r\n modifier onlyRole(string memory role) {\r\n _checkRole(role, msg.sender);\r\n _;\r\n }\r\n\r\n /// @notice Initialize DAO action and role permissions\r\n /// @param dao Address to receive DAO role\r\n /// @param roles What permissions are assigned to\r\n /// @param roleAdmins Roles which have the ability to remove or add members\r\n /// @param members Addresses to be granted the specified roles\r\n /// @param targets Contract addresses for actions to be defined on\r\n /// @param functionDescs Function descriptions used to define actions\r\n /// @param actionRoles Roles being granted permission for an action\r\n function initialize(\r\n address dao,\r\n string[] memory roles,\r\n string[] memory roleAdmins,\r\n address[][] memory members,\r\n address[] memory targets,\r\n string[] memory functionDescs,\r\n string[][] memory actionRoles\r\n ) external initializer {\r\n if (\r\n roles.length != roleAdmins.length ||\r\n roles.length != members.length ||\r\n targets.length != functionDescs.length ||\r\n targets.length != actionRoles.length\r\n ) revert UnequalArrayLengths();\r\n\r\n _grantRole(DAO_ROLE, dao);\r\n _grantRolesAndAdmins(roles, roleAdmins, members);\r\n _addActionsRoles(targets, functionDescs, actionRoles);\r\n __UUPSUpgradeable_init();\r\n _registerInterface(type(IDAOAccessControl).interfaceId);\r\n }\r\n\r\n /// @notice Grants roles to the specified addresses and defines admin roles\r\n /// @notice This function can only be called by the DAO\r\n /// @param roles The roles being granted\r\n /// @param roleAdmins The roles being granted as admins of the specified of roles\r\n /// @param members Addresses being granted each specified role\r\n function daoGrantRolesAndAdmins(\r\n string[] memory roles,\r\n string[] memory roleAdmins,\r\n address[][] memory members\r\n ) external onlyRole(DAO_ROLE) {\r\n _grantRolesAndAdmins(roles, roleAdmins, members);\r\n }\r\n\r\n /// @notice Grants roles to the specified addresses\r\n /// @notice This function can only be called by the DAO\r\n /// @param roles The roles being granted\r\n /// @param members Addresses being granted each specified role\r\n function daoGrantRoles(string[] memory roles, address[][] memory members)\r\n external\r\n onlyRole(DAO_ROLE)\r\n {\r\n _grantRoles(roles, members);\r\n }\r\n\r\n /// @notice Authorizes roles to execute the specified actions\r\n /// @notice This function can only be called by the DAO\r\n /// @param targets The contract addresses that the action functions are implemented on\r\n /// @param functionDescs The function descriptions used to define the actions\r\n /// @param roles Roles being granted permission for an action\r\n function daoAddActionsRoles(\r\n address[] memory targets,\r\n string[] memory functionDescs,\r\n string[][] memory roles\r\n ) external onlyRole(DAO_ROLE) {\r\n _addActionsRoles(targets, functionDescs, roles);\r\n }\r\n\r\n /// @notice Removes autorization for roles to execute the specified actions\r\n /// @notice This function can only be called by the DAO\r\n /// @param targets The contract addresses that the action functions are implemented on\r\n /// @param functionDescs The function description used to define the actions\r\n /// @param roles Roles that action permissions are being removed on\r\n function daoRemoveActionsRoles(\r\n address[] memory targets,\r\n string[] memory functionDescs,\r\n string[][] memory roles\r\n ) external onlyRole(DAO_ROLE) {\r\n if (targets.length != functionDescs.length)\r\n revert UnequalArrayLengths();\r\n if (targets.length != roles.length) revert UnequalArrayLengths();\r\n uint256 actionsLength = targets.length;\r\n for (uint256 i = 0; i < actionsLength; ) {\r\n uint256 rolesLength = roles[i].length;\r\n for (uint256 j = 0; j < rolesLength; ) {\r\n _removeActionRole(targets[i], functionDescs[i], roles[i][j]);\r\n unchecked {\r\n j++;\r\n }\r\n }\r\n unchecked {\r\n i++;\r\n }\r\n }\r\n }\r\n\r\n /// @notice Grants a role to the specified address\r\n /// @notice This function can only be called by an admin of the specified role\r\n /// @param role The role being granted\r\n /// @param account The address being granted the specified role\r\n function adminGrantRole(string memory role, address account)\r\n external\r\n onlyRole(getRoleAdmin(role))\r\n {\r\n _grantRole(role, account);\r\n }\r\n\r\n /// @notice Revokes a role from the specified address\r\n /// @notice This function can only be called by an admin of the specified role\r\n /// @param role The role being revoked\r\n /// @param account The address the role is being revoked from\r\n function adminRevokeRole(string memory role, address account)\r\n external\r\n onlyRole(getRoleAdmin(role))\r\n {\r\n _revokeRole(role, account);\r\n }\r\n\r\n /// @notice Enables an address to remove one of its own roles\r\n /// @notice This function can only be called by the account specified\r\n /// @param role The role being renounced\r\n /// @param account The address renouncing the role\r\n function userRenounceRole(string memory role, address account) external {\r\n if (account != msg.sender) {\r\n revert OnlySelfRenounce();\r\n }\r\n\r\n _revokeRole(role, account);\r\n } \r\n\r\n /// @notice Checks if a caller has the permissions to execute the specific action\r\n /// @param caller Address attempting to execute the action\r\n /// @param target Contract address corresponding to the action\r\n /// @param sig The function signature used to define the action\r\n function actionIsAuthorized(\r\n address caller,\r\n address target,\r\n bytes4 sig\r\n ) external view returns (bool isAuthorized) {\r\n string[] memory roles = _actionsToRoles[target][sig];\r\n uint256 roleLength = roles.length;\r\n\r\n for (uint256 i = 0; i < roleLength; ) {\r\n if (hasRole(roles[i], caller)) {\r\n isAuthorized = true;\r\n break;\r\n }\r\n unchecked {\r\n i++;\r\n }\r\n }\r\n }\r\n\r\n /// @notice Returns the roles autorized to execute the specified action\r\n /// @param target Contract address corresponding to the action\r\n /// @param functionDesc The function description used to define the action\r\n function getActionRoles(address target, string memory functionDesc)\r\n external\r\n view\r\n returns (string[] memory roles)\r\n {\r\n bytes4 encodedSig = bytes4(keccak256(abi.encodePacked(functionDesc)));\r\n return _actionsToRoles[target][encodedSig];\r\n }\r\n\r\n /// @notice Checks if a specific role is authorized for an action\r\n /// @param role Role that authorization is being checked on\r\n /// @param target Contract address corresponding to the action\r\n /// @param functionDesc Function description used to define the action\r\n /// @return isAuthorized Indicates whether the role is authorized to execute the action\r\n function isRoleAuthorized(\r\n string calldata role,\r\n address target,\r\n string memory functionDesc\r\n ) external view returns (bool isAuthorized) {\r\n bytes4 encodedSig = bytes4(keccak256(abi.encodePacked(functionDesc)));\r\n string[] memory roles = _actionsToRoles[target][encodedSig];\r\n uint256 rolesLength = roles.length;\r\n\r\n for (uint256 i = 0; i < rolesLength; ) {\r\n if (\r\n keccak256(abi.encodePacked(role)) ==\r\n keccak256(abi.encodePacked(roles[i]))\r\n ) {\r\n isAuthorized = true;\r\n break;\r\n }\r\n unchecked {\r\n i++;\r\n }\r\n }\r\n }\r\n\r\n /// @notice Returns whether the account has been granted the role\r\n /// @param role Role that authorization is being checked on\r\n /// @param account Address that the role authorization is being check on\r\n /// @return boolean Indicates whether the address has been granted the role\r\n function hasRole(string memory role, address account)\r\n public\r\n view\r\n returns (bool)\r\n {\r\n if (\r\n keccak256(bytes(role)) ==\r\n keccak256(bytes(OPEN_ROLE))\r\n ) {\r\n return true;\r\n } else {\r\n return _roles[role].members[account];\r\n }\r\n }\r\n\r\n /// @notice Returns the role that is the admin of the specified role\r\n /// @param role Role that the admin role is being returned for\r\n /// @return string The admin role of the specified role\r\n function getRoleAdmin(string memory role)\r\n public\r\n view\r\n returns (string memory)\r\n {\r\n return _roles[role].adminRole;\r\n }\r\n\r\n /// @notice Sets a role as the admin of another role\r\n /// @param role The role the admin is being set for\r\n /// @param adminRole The role that is being assigned as an admin\r\n function _setRoleAdmin(string memory role, string memory adminRole)\r\n internal\r\n {\r\n string memory previousAdminRole = getRoleAdmin(role);\r\n _roles[role].adminRole = adminRole;\r\n emit RoleAdminChanged(role, previousAdminRole, adminRole);\r\n }\r\n\r\n /// @notice Grants a role to the specified address\r\n /// @param role The role being granted\r\n /// @param account The address being granted the specified role\r\n function _grantRole(string memory role, address account) internal {\r\n if (!hasRole(role, account)) {\r\n _roles[role].members[account] = true;\r\n emit RoleGranted(role, account, msg.sender);\r\n }\r\n }\r\n\r\n /// @notice Revokes a role from the specified address\r\n /// @param role The role being revoked\r\n /// @param account The address the role is being revoked from\r\n function _revokeRole(string memory role, address account) internal {\r\n if (hasRole(role, account)) {\r\n _roles[role].members[account] = false;\r\n emit RoleRevoked(role, account, msg.sender);\r\n }\r\n }\r\n\r\n /// @notice Grants roles to the specified addresses and defines admin roles\r\n /// @param roles The roles being granted\r\n /// @param roleAdmins The roles being granted as admins of the specified of roles\r\n /// @param members Addresses being granted each specified role\r\n function _grantRolesAndAdmins(\r\n string[] memory roles,\r\n string[] memory roleAdmins,\r\n address[][] memory members\r\n ) internal {\r\n if (roles.length != roleAdmins.length) revert UnequalArrayLengths();\r\n if (roles.length != members.length) revert UnequalArrayLengths();\r\n\r\n uint256 rolesLength = roles.length;\r\n for (uint256 i = 0; i < rolesLength; ) {\r\n _setRoleAdmin(roles[i], roleAdmins[i]);\r\n\r\n uint256 membersLength = members[i].length;\r\n for (uint256 j = 0; j < membersLength; ) {\r\n _grantRole(roles[i], members[i][j]);\r\n unchecked {\r\n j++;\r\n }\r\n }\r\n unchecked {\r\n i++;\r\n }\r\n }\r\n }\r\n\r\n /// @notice Grants roles to the specified addresses and defines admin roles\r\n /// @param roles The roles being granted\r\n /// @param members Addresses being granted each specified role\r\n function _grantRoles(string[] memory roles, address[][] memory members)\r\n internal\r\n {\r\n if (roles.length != members.length) revert UnequalArrayLengths();\r\n\r\n uint256 rolesLength = roles.length;\r\n for (uint256 i = 0; i < rolesLength; ) {\r\n uint256 membersLength = members[i].length;\r\n for (uint256 j = 0; j < membersLength; ) {\r\n _grantRole(roles[i], members[i][j]);\r\n unchecked {\r\n j++;\r\n }\r\n }\r\n unchecked {\r\n i++;\r\n }\r\n }\r\n }\r\n\r\n /// @notice Authorizes roles to execute the specified actions\r\n /// @param targets The contract addresses that the action functions are implemented on\r\n /// @param functionDescs The function descriptions used to define the actions\r\n /// @param roles Roles being granted permission for an action\r\n function _addActionsRoles(\r\n address[] memory targets,\r\n string[] memory functionDescs,\r\n string[][] memory roles\r\n ) internal {\r\n if (targets.length != functionDescs.length)\r\n revert UnequalArrayLengths();\r\n if (targets.length != roles.length) revert UnequalArrayLengths();\r\n\r\n uint256 targetsLength = targets.length;\r\n for (uint256 i = 0; i < targetsLength; ) {\r\n uint256 rolesLength = roles[i].length;\r\n for (uint256 j = 0; j < rolesLength; ) {\r\n _addActionRole(targets[i], functionDescs[i], roles[i][j]);\r\n unchecked {\r\n j++;\r\n }\r\n }\r\n unchecked {\r\n i++;\r\n }\r\n }\r\n }\r\n\r\n /// @notice Authorizes a role to execute the specified action\r\n /// @param target The contract address that the action function is implemented on\r\n /// @param functionDesc The function description used to define the action\r\n /// @param role Role being granted permission for an action\r\n function _addActionRole(\r\n address target,\r\n string memory functionDesc,\r\n string memory role\r\n ) internal {\r\n bytes4 encodedSig = bytes4(keccak256(abi.encodePacked(functionDesc)));\r\n _actionsToRoles[target][encodedSig].push(role);\r\n\r\n emit ActionRoleAdded(target, functionDesc, encodedSig, role);\r\n }\r\n\r\n /// @notice Removes authorization of a role to execute the specified action\r\n /// @param target The contract address that the action function is implemented on\r\n /// @param functionDesc The function description used to define the action\r\n /// @param role Role that the action authorization is being removed on\r\n function _removeActionRole(\r\n address target,\r\n string memory functionDesc,\r\n string memory role\r\n ) internal {\r\n bytes4 encodedSig = bytes4(keccak256(abi.encodePacked(functionDesc)));\r\n uint256 rolesLength = _actionsToRoles[target][encodedSig].length;\r\n for (uint256 i = 0; i < rolesLength; ) {\r\n if (\r\n keccak256(\r\n abi.encodePacked(_actionsToRoles[target][encodedSig][i])\r\n ) == keccak256(abi.encodePacked(role))\r\n ) {\r\n _actionsToRoles[target][encodedSig][i] = _actionsToRoles[\r\n target\r\n ][encodedSig][rolesLength - 1];\r\n _actionsToRoles[target][encodedSig].pop();\r\n\r\n emit ActionRoleRemoved(target, functionDesc, encodedSig, role);\r\n\r\n break;\r\n }\r\n unchecked {\r\n i++;\r\n }\r\n }\r\n }\r\n\r\n /// @notice Reverts when msg.sender is not authorized to upgrade the contract\r\n /// @notice Only addresses that have the DAO_ROLE role are authorized\r\n /// @notice Called by upgradeTo and upgradeToAndCall\r\n /// @param newImplementation New implementation contract address being upgraded to\r\n function _authorizeUpgrade(address newImplementation)\r\n internal\r\n override\r\n onlyRole(DAO_ROLE)\r\n {}\r\n\r\n /// @notice Reverts with a standard message if account is missing role\r\n /// @param role Role being checked\r\n /// @param account Address that role is being checked on\r\n function _checkRole(string memory role, address account) internal view {\r\n if (!hasRole(role, account)) {\r\n revert MissingRole(account, role);\r\n }\r\n }\r\n}\r\n" - }, - "@fractal-framework/core-contracts/contracts/DAO.sol": { - "content": "//SPDX-License-Identifier: Unlicense\r\npragma solidity ^0.8.0;\r\n\r\nimport \"@openzeppelin/contracts/utils/Address.sol\";\r\n\r\nimport \"./interfaces/IDAO.sol\";\r\nimport \"./ModuleBase.sol\";\r\n\r\n/// @notice A minimum viable DAO contract\r\ncontract DAO is IDAO, ModuleBase {\r\n /// @notice Function for initializing the contract that can only be called once\r\n /// @param _accessControl The address of the access control contract\r\n /// @param _moduleFactory The address of the module factory\r\n /// @param _name Name of the Dao\r\n function initialize(address _accessControl, address _moduleFactory, string calldata _name) external initializer {\r\n __initBase(_accessControl, _moduleFactory, _name);\r\n _registerInterface(type(IDAO).interfaceId);\r\n }\r\n\r\n /// @notice A function for executing function calls from the DAO\r\n /// @param targets An array of addresses to target for the function calls\r\n /// @param values An array of ether values to send with the function calls\r\n /// @param calldatas An array of bytes defining the function calls\r\n function execute(\r\n address[] calldata targets,\r\n uint256[] calldata values,\r\n bytes[] calldata calldatas\r\n ) external authorized {\r\n if (\r\n targets.length != values.length ||\r\n targets.length != calldatas.length\r\n ) revert UnequalArrayLengths();\r\n string memory errorMessage = \"DAO: call reverted without message\";\r\n uint256 targetlength = targets.length;\r\n for (uint256 i = 0; i < targetlength; ) {\r\n (bool success, bytes memory returndata) = targets[i].call{\r\n value: values[i]\r\n }(calldatas[i]);\r\n Address.verifyCallResult(success, returndata, errorMessage);\r\n unchecked {\r\n i++;\r\n }\r\n }\r\n emit Executed(targets, values, calldatas);\r\n }\r\n}\r\n" - }, - "contracts/hardhat-dependency-compiler/@fractal-framework/core-contracts/contracts/DAO.sol": { - "content": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >0.0.0;\nimport '@fractal-framework/core-contracts/contracts/DAO.sol';\n" - }, - "contracts/hardhat-dependency-compiler/@fractal-framework/core-contracts/contracts/DAOAccessControl.sol": { - "content": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >0.0.0;\nimport '@fractal-framework/core-contracts/contracts/DAOAccessControl.sol';\n" - }, - "contracts/hardhat-dependency-compiler/@fractal-framework/core-contracts/contracts/DAOFactory.sol": { - "content": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >0.0.0;\nimport '@fractal-framework/core-contracts/contracts/DAOFactory.sol';\n" - } - }, - "settings": { - "optimizer": { - "enabled": true, - "runs": 200 - }, - "outputSelection": { - "*": { - "*": [ - "abi", - "evm.bytecode", - "evm.deployedBytecode", - "evm.methodIdentifiers", - "metadata", - "storageLayout", - "devdoc", - "userdoc", - "evm.gasEstimates" - ], - "": [ - "ast" - ] - } - }, - "metadata": { - "useLiteralContent": true - } - } -} \ No newline at end of file