# MezzHub [Git Source](https://github.com/EntreDevelopers-Lab-Inc/Mezz-Companies/blob/f7a3e84e3dd5bb33c4bd7f77283983f9e8ba20b2/src/MezzHub.sol) **Inherits:** CommonValidation, ModifiedOwnable2StepUpgradeable, DelayedUUPSUpgradeable, IMezzHub **Author:** Daniel Yamagata & Jerry Qi & Naveen Ailawadi The central contract of the Mezzanine protocol. It manages the protocol state and whitelists and is used by 'core' contracts to query 'non-core' contracts *The addresses of the 'non-core' contracts can only be updated via an upgrade, which must be proposed and executed by the 'owner'. Upgrades require a delay before they can be executed. Similarly, the transfer of ownership requires a delay before it can be accepted. The renouncement of ownership is disabled to prevent griefing by a compromised 'owner'. The re-enablement of this functionality must be done via an upgrade* ## State Variables ### PRECISION\_FACTOR ```solidity uint256 public constant PRECISION_FACTOR = Constants.PRECISION_FACTOR; ``` ### MezzHubStorageLocation ```solidity bytes32 private constant MezzHubStorageLocation = 0x3de7a073c0cce790cf3a28a9e9c6ae84d1b91b340e346453198ee61a13723200; ``` ## Functions ### \_getMezzHubStorage ```solidity function _getMezzHubStorage() internal pure returns (MezzHubStorage storage $); ``` ### constructor ```solidity constructor(); ``` ### onlyOwnerOrDefender *Reverts if the caller is not the 'owner' or a 'defender'* ```solidity modifier onlyOwnerOrDefender(); ``` ### ownershipTransferSnapshot Returns the snapshot of the ownership transfer. This snapshot must pass before a pending ownership transfer can occur. If there is no pending ownership transfer, this will will return zero ```solidity function ownershipTransferSnapshot() public view returns (uint256); ``` ### frozenSnapshot Returns the snapshot of the protocol freeze. This snapshot must pass before the protocol can ```solidity function frozenSnapshot() public view returns (uint256); ``` ### owner Returns the address of the Mezz Hub owner ```solidity function owner() public view virtual override(IMezzHub, OwnableUpgradeable) returns (address); ``` ### init Initializes the Mezz Hub state. Can only be called once ```solidity function init(address initOwner, address initDocumentRegistry, address initMezzDeployer, address initFeeController) external initializer; ``` **Parameters** | Name | Type | Description | | ---------------------- | --------- | ----------------------------------------- | | `initOwner` | `address` | The address of the initial Mezz Hub owner | | `initDocumentRegistry` | `address` | The address of the Document Registry | | `initMezzDeployer` | `address` | The address of the Mezz Deployer | | `initFeeController` | `address` | The address of the Fee Controller | ### \_\_MezzHub\_init ```solidity function __MezzHub_init(address initDocumentRegistry, address initMezzDeployer, address initFeeController) internal onlyInitializing; ``` ### transferOwnership *Overridden 'transferOwnership' such that a snapshot is taken upon the transfer of ownership* ```solidity function transferOwnership(address newOwner) public virtual override; ``` ### acceptOwnership *Overridden '\_acceptOwnership' such that the snapshot is validated before the ownership transfer is accepted* ```solidity function acceptOwnership() public virtual override; ``` ### cancelOwnershipTransfer *Cancels a pending ownership transfer. Only callable by the 'owner' or a 'defender' Deletes the snapshot of the ownership transfer and the pending owner* ```solidity function cancelOwnershipTransfer() public virtual onlyOwnerOrDefender; ``` ### renounceOwnership *Deprecation of 'renounceOwnership' from OwnableUpgradeable to prevent griefing by a compromised 'owner'* ```solidity function renounceOwnership() public virtual override; ``` ### freezeProtocol Freezes the protocol for 'freezeDuration', which can be up to 14 days. Only callable by the 'owner' or a 'defender' The protocol can be re-frozen at any point while it is frozen. ```solidity function freezeProtocol(uint48 freezeDuration) external onlyOwnerOrDefender; ``` **Parameters** | Name | Type | Description | | ---------------- | -------- | -------------------------------------------------- | | `freezeDuration` | `uint48` | The duration to freeze the protocol for in seconds | ### setProtocolState Sets the protocol state. Only callabe by the owner. *Protocol state is defined by the following enum:* * *0: Active* * *1: Paused* * *2: Frozen* *If protocol state is set by this function, it will be permanently set until this function is called again to change state.* ```solidity function setProtocolState(DataTypes.ProtocolState newState) external override onlyOwner; ``` **Parameters** | Name | Type | Description | | ---------- | ------------------------- | ------------------------- | | `newState` | `DataTypes.ProtocolState` | The protocol state to set | ### proposeUpgrade Proposes an upgrade to the contract's implementation *The caller must be authorized to propose an upgrade. This authorization is determined by inheriting contracts* ```solidity function proposeUpgrade(address newImplementation) external override onlyOwner returns (uint256); ``` **Parameters** | Name | Type | Description | | ------------------- | --------- | ------------------------------------- | | `newImplementation` | `address` | The address of the new implementation | **Returns** | Name | Type | Description | | -------- | --------- | ------------------------------------------------------- | | `` | `uint256` | The snapshot of the pending upgrade as a unix-timestamp | ### cancelProposedUpgrade Cancels the pending upgrade, deleting the 'pendingUpgrade' and 'pendingUpgradeSnapshot' in storage *The caller must be authorized to cancel a pending upgrade. This authorization is determined by inheriting contracts* ```solidity function cancelProposedUpgrade() external override onlyOwnerOrDefender; ``` ### setFrozenImplementation Sets the 'implementationToSet' to 'setting'. If true and 'implementationToSet' is StateAware, the implementation's pausable and freezable functions will revert Only callable by the 'owner' ```solidity function setFrozenImplementation(address implementationToSet, bool setting) external onlyOwner; ``` ### setFrozenDeployment Sets the 'deploymentToSet' to 'setting'. If true, the deployment's pausable and freezable functions will revert Only callable by the 'owner' or a 'defender' ```solidity function setFrozenDeployment(address deploymentToSet, bool setting) external onlyOwnerOrDefender; ``` ### addWhitelistedDenominationAsset Adds 'denominationAssetToAdd' to the denomination asset whitelist. Only callable by the 'owner' *The owner should be cautious to never add ERC777s to the whitelist to prevent possible reentrancy attacks* ```solidity function addWhitelistedDenominationAsset(address denominationAssetToAdd) external onlyOwner; ``` ### removeWhitelistedDenominationAsset Removes 'denominationAssetToRemove' from the denomination asset whitelist. Only callable by the 'owner' ```solidity function removeWhitelistedDenominationAsset(address denominationAssetToRemove) external onlyOwner; ``` ### addDefender Adds 'defenderToAdd' to the set of defenders. Only callable by the 'owner' ```solidity function addDefender(address defenderToAdd) external onlyOwner; ``` ### removeDefender Removes 'defenderToRemove' from the set of defenders. Only callable by the 'owner' ```solidity function removeDefender(address defenderToRemove) external onlyOwner; ``` ### isDefender Returns true if 'defenderToCheck' is a defender, false otherwise ```solidity function isDefender(address defenderToCheck) external view returns (bool); ``` ### isDenominationAsset Returns true 'denominationAssetToCheck' is whitelisted, false otherwise ```solidity function isDenominationAsset(address denominationAssetToCheck) external view returns (bool); ``` ### isDeploymentFrozen Returns true if 'deploymentToCheck' is frozen, false otherwise ```solidity function isDeploymentFrozen(address deploymentToCheck) external view returns (bool); ``` ### isImplementationFrozen Returns true if 'implementationToCheck' is frozen, false otherwise ```solidity function isImplementationFrozen(address implementationToCheck) external view returns (bool); ``` ### getDefenders Returns the set of defenders as an array of addresses ```solidity function getDefenders() external view returns (address[] memory); ``` ### getDenominationAssets Returns the set of denomination assets in no specific order ```solidity function getDenominationAssets() external view returns (address[] memory); ``` ### getDocumentRegistry Returns the address of the Document Registry *Used by core contracts* ```solidity function getDocumentRegistry() external view returns (address); ``` ### getFeeController Returns the address of the fee controller *Used by core contracts* ```solidity function getFeeController() external view returns (address); ``` ### getMezzDeployer Returns the address of the Mezz Deployer *Used by the core contracts* ```solidity function getMezzDeployer() external view returns (address); ``` ### getProtocolState Returns the Protocol State as an enum, DataTypes.ProtocolState \*The protocol state is defined by the following enum: * 0: Active * 1: Paused * 2: Frozen The protocol can be frozen in two ways: * (1) The protocol's state was set to 'Frozen' by the owner via 'setProtocolState()'. If this is the case, it can be unfrozen at any point in time * (2) The 'owner' or a 'defender' set the protocol's state to 'Frozen' via 'freezeProtocol()', which freezes the protocol for a period of time. It cannot be unfrozen until this time passes\* ```solidity function getProtocolState() external view returns (DataTypes.ProtocolState); ``` ### \_setDocumentRegistry ```solidity function _setDocumentRegistry(address newDocumentRegistry) internal; ``` ### \_setMezzDeployer ```solidity function _setMezzDeployer(address newMezzDeployer) internal; ``` ### \_setFeeController ```solidity function _setFeeController(address newFeeController) internal; ``` ### \_validateCallerIsOwnerOrDefender *Reverts if the caller is not the 'owner' or a 'defender'* ```solidity function _validateCallerIsOwnerOrDefender() internal view; ``` ### \_isCallerDefender ```solidity function _isCallerDefender() internal view returns (bool); ``` ### \_isCallerOwner ```solidity function _isCallerOwner() internal view returns (bool); ``` ### \_authorizeUpgrade *Overridden '\_authorizeUpgrade()' from DelayedUUPSUpgradeable such that only the 'owner' can execute an upgrade* ```solidity function _authorizeUpgrade(address newImplementation) internal view override onlyOwner; ``` ## Structs ### MezzHubStorage ```solidity struct MezzHubStorage { address _documentRegistry; uint96 _ownershipTransferSnapshot; address _mezzDeployer; address _feeController; DataTypes.ProtocolState _protocolState; uint48 _frozenSnapshot; EnumerableSet.AddressSet _defenders; EnumerableSet.AddressSet _denominationAssetWhitelist; mapping(address => bool) _frozenImplementations; mapping(address => bool) _frozenDeployments; } ``` --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://docs.mezzanine.xyz/smart-contracts/source-code/mezzhub.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.