File size: 149,848 Bytes
f998fcd |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 |
{
"language": "Solidity",
"sources": {
"src/manager/Manager.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport { UUPS } from \"../lib/proxy/UUPS.sol\";\nimport { Ownable } from \"../lib/utils/Ownable.sol\";\nimport { ERC1967Proxy } from \"../lib/proxy/ERC1967Proxy.sol\";\n\nimport { ManagerStorageV1 } from \"./storage/ManagerStorageV1.sol\";\nimport { IManager } from \"./IManager.sol\";\nimport { IToken } from \"../token/IToken.sol\";\nimport { IBaseMetadata } from \"../token/metadata/interfaces/IBaseMetadata.sol\";\nimport { IAuction } from \"../auction/IAuction.sol\";\nimport { ITreasury } from \"../governance/treasury/ITreasury.sol\";\nimport { IGovernor } from \"../governance/governor/IGovernor.sol\";\n\n/// @title Manager\n/// @author Rohan Kulkarni\n/// @notice The DAO deployer and upgrade manager\ncontract Manager is IManager, UUPS, Ownable, ManagerStorageV1 {\n /// ///\n /// IMMUTABLES ///\n /// ///\n\n /// @notice The token implementation address\n address public immutable tokenImpl;\n\n /// @notice The metadata renderer implementation address\n address public immutable metadataImpl;\n\n /// @notice The auction house implementation address\n address public immutable auctionImpl;\n\n /// @notice The treasury implementation address\n address public immutable treasuryImpl;\n\n /// @notice The governor implementation address\n address public immutable governorImpl;\n\n /// ///\n /// CONSTRUCTOR ///\n /// ///\n\n constructor(\n address _tokenImpl,\n address _metadataImpl,\n address _auctionImpl,\n address _treasuryImpl,\n address _governorImpl\n ) payable initializer {\n tokenImpl = _tokenImpl;\n metadataImpl = _metadataImpl;\n auctionImpl = _auctionImpl;\n treasuryImpl = _treasuryImpl;\n governorImpl = _governorImpl;\n }\n\n /// ///\n /// INITIALIZER ///\n /// ///\n\n /// @notice Initializes ownership of the manager contract\n /// @param _newOwner The owner address to set (will be transferred to the Builder DAO once its deployed)\n function initialize(address _newOwner) external initializer {\n // Ensure an owner is specified\n if (_newOwner == address(0)) revert ADDRESS_ZERO();\n\n // Set the contract owner\n __Ownable_init(_newOwner);\n }\n\n /// ///\n /// DAO DEPLOY ///\n /// ///\n\n /// @notice Deploys a DAO with custom token, auction, and governance settings\n /// @param _founderParams The DAO founders\n /// @param _tokenParams The ERC-721 token settings\n /// @param _auctionParams The auction settings\n /// @param _govParams The governance settings\n function deploy(\n FounderParams[] calldata _founderParams,\n TokenParams calldata _tokenParams,\n AuctionParams calldata _auctionParams,\n GovParams calldata _govParams\n )\n external\n returns (\n address token,\n address metadata,\n address auction,\n address treasury,\n address governor\n )\n {\n // Used to store the address of the first (or only) founder\n // This founder is responsible for adding token artwork and launching the first auction -- they're also free to transfer this responsiblity\n address founder;\n\n // Ensure at least one founder is provided\n if ((founder = _founderParams[0].wallet) == address(0)) revert FOUNDER_REQUIRED();\n\n // Deploy the DAO's ERC-721 governance token\n token = address(new ERC1967Proxy(tokenImpl, \"\"));\n\n // Use the token address to precompute the DAO's remaining addresses\n bytes32 salt = bytes32(uint256(uint160(token)) << 96);\n\n // Deploy the remaining DAO contracts\n metadata = address(new ERC1967Proxy{ salt: salt }(metadataImpl, \"\"));\n auction = address(new ERC1967Proxy{ salt: salt }(auctionImpl, \"\"));\n treasury = address(new ERC1967Proxy{ salt: salt }(treasuryImpl, \"\"));\n governor = address(new ERC1967Proxy{ salt: salt }(governorImpl, \"\"));\n\n daoAddressesByToken[token] = DAOAddresses({ metadata: metadata, auction: auction, treasury: treasury, governor: governor });\n\n // Initialize each instance with the provided settings\n IToken(token).initialize({\n founders: _founderParams,\n initStrings: _tokenParams.initStrings,\n metadataRenderer: metadata,\n auction: auction,\n initialOwner: founder\n });\n IBaseMetadata(metadata).initialize({ initStrings: _tokenParams.initStrings, token: token });\n IAuction(auction).initialize({\n token: token,\n founder: founder,\n treasury: treasury,\n duration: _auctionParams.duration,\n reservePrice: _auctionParams.reservePrice\n });\n ITreasury(treasury).initialize({ governor: governor, timelockDelay: _govParams.timelockDelay });\n IGovernor(governor).initialize({\n treasury: treasury,\n token: token,\n vetoer: _govParams.vetoer,\n votingDelay: _govParams.votingDelay,\n votingPeriod: _govParams.votingPeriod,\n proposalThresholdBps: _govParams.proposalThresholdBps,\n quorumThresholdBps: _govParams.quorumThresholdBps\n });\n\n emit DAODeployed({ token: token, metadata: metadata, auction: auction, treasury: treasury, governor: governor });\n }\n\n /// ///\n /// DAO ADDRESSES ///\n /// ///\n\n /// @notice A DAO's contract addresses from its token\n /// @param _token The ERC-721 token address\n /// @return metadata Metadata deployed address\n /// @return auction Auction deployed address\n /// @return treasury Treasury deployed address\n /// @return governor Governor deployed address\n function getAddresses(address _token)\n external\n view\n returns (\n address metadata,\n address auction,\n address treasury,\n address governor\n )\n {\n DAOAddresses storage addresses = daoAddressesByToken[_token];\n\n metadata = addresses.metadata;\n auction = addresses.auction;\n treasury = addresses.treasury;\n governor = addresses.governor;\n }\n\n /// ///\n /// DAO UPGRADES ///\n /// ///\n\n /// @notice If an implementation is registered by the Builder DAO as an optional upgrade\n /// @param _baseImpl The base implementation address\n /// @param _upgradeImpl The upgrade implementation address\n function isRegisteredUpgrade(address _baseImpl, address _upgradeImpl) external view returns (bool) {\n return isUpgrade[_baseImpl][_upgradeImpl];\n }\n\n /// @notice Called by the Builder DAO to offer implementation upgrades for created DAOs\n /// @param _baseImpl The base implementation address\n /// @param _upgradeImpl The upgrade implementation address\n function registerUpgrade(address _baseImpl, address _upgradeImpl) external onlyOwner {\n isUpgrade[_baseImpl][_upgradeImpl] = true;\n\n emit UpgradeRegistered(_baseImpl, _upgradeImpl);\n }\n\n /// @notice Called by the Builder DAO to remove an upgrade\n /// @param _baseImpl The base implementation address\n /// @param _upgradeImpl The upgrade implementation address\n function removeUpgrade(address _baseImpl, address _upgradeImpl) external onlyOwner {\n delete isUpgrade[_baseImpl][_upgradeImpl];\n\n emit UpgradeRemoved(_baseImpl, _upgradeImpl);\n }\n\n /// ///\n /// MANAGER UPGRADE ///\n /// ///\n\n /// @notice Ensures the caller is authorized to upgrade the contract\n /// @dev This function is called in `upgradeTo` & `upgradeToAndCall`\n /// @param _newImpl The new implementation address\n function _authorizeUpgrade(address _newImpl) internal override onlyOwner {}\n}\n"
},
"src/lib/proxy/UUPS.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport { IUUPS } from \"../interfaces/IUUPS.sol\";\nimport { ERC1967Upgrade } from \"./ERC1967Upgrade.sol\";\n\n/// @title UUPS\n/// @author Rohan Kulkarni\n/// @notice Modified from OpenZeppelin Contracts v4.7.3 (proxy/utils/UUPSUpgradeable.sol)\n/// - Uses custom errors declared in IUUPS\n/// - Inherits a modern, minimal ERC1967Upgrade\nabstract contract UUPS is IUUPS, ERC1967Upgrade {\n /// ///\n /// IMMUTABLES ///\n /// ///\n\n /// @dev The address of the implementation\n address private immutable __self = address(this);\n\n /// ///\n /// MODIFIERS ///\n /// ///\n\n /// @dev Ensures that execution is via proxy delegatecall with the correct implementation\n modifier onlyProxy() {\n if (address(this) == __self) revert ONLY_DELEGATECALL();\n if (_getImplementation() != __self) revert ONLY_PROXY();\n _;\n }\n\n /// @dev Ensures that execution is via direct call\n modifier notDelegated() {\n if (address(this) != __self) revert ONLY_CALL();\n _;\n }\n\n /// ///\n /// FUNCTIONS ///\n /// ///\n\n /// @dev Hook to authorize an implementation upgrade\n /// @param _newImpl The new implementation address\n function _authorizeUpgrade(address _newImpl) internal virtual;\n\n /// @notice Upgrades to an implementation\n /// @param _newImpl The new implementation address\n function upgradeTo(address _newImpl) external onlyProxy {\n _authorizeUpgrade(_newImpl);\n _upgradeToAndCallUUPS(_newImpl, \"\", false);\n }\n\n /// @notice Upgrades to an implementation with an additional function call\n /// @param _newImpl The new implementation address\n /// @param _data The encoded function call\n function upgradeToAndCall(address _newImpl, bytes memory _data) external payable onlyProxy {\n _authorizeUpgrade(_newImpl);\n _upgradeToAndCallUUPS(_newImpl, _data, true);\n }\n\n /// @notice The storage slot of the implementation address\n function proxiableUUID() external view notDelegated returns (bytes32) {\n return _IMPLEMENTATION_SLOT;\n }\n}\n"
},
"src/lib/utils/Ownable.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport { IOwnable } from \"../interfaces/IOwnable.sol\";\nimport { Initializable } from \"../utils/Initializable.sol\";\n\n/// @title Ownable\n/// @author Rohan Kulkarni\n/// @notice Modified from OpenZeppelin Contracts v4.7.3 (access/OwnableUpgradeable.sol)\n/// - Uses custom errors declared in IOwnable\n/// - Adds optional two-step ownership transfer (`safeTransferOwnership` + `acceptOwnership`)\nabstract contract Ownable is IOwnable, Initializable {\n /// ///\n /// STORAGE ///\n /// ///\n\n /// @dev The address of the owner\n address internal _owner;\n\n /// @dev The address of the pending owner\n address internal _pendingOwner;\n\n /// ///\n /// MODIFIERS ///\n /// ///\n\n /// @dev Ensures the caller is the owner\n modifier onlyOwner() {\n if (msg.sender != _owner) revert ONLY_OWNER();\n _;\n }\n\n /// @dev Ensures the caller is the pending owner\n modifier onlyPendingOwner() {\n if (msg.sender != _pendingOwner) revert ONLY_PENDING_OWNER();\n _;\n }\n\n /// ///\n /// FUNCTIONS ///\n /// ///\n\n /// @dev Initializes contract ownership\n /// @param _initialOwner The initial owner address\n function __Ownable_init(address _initialOwner) internal onlyInitializing {\n _owner = _initialOwner;\n\n emit OwnerUpdated(address(0), _initialOwner);\n }\n\n /// @notice The address of the owner\n function owner() public virtual view returns (address) {\n return _owner;\n }\n\n /// @notice The address of the pending owner\n function pendingOwner() public view returns (address) {\n return _pendingOwner;\n }\n\n /// @notice Forces an ownership transfer from the last owner\n /// @param _newOwner The new owner address\n function transferOwnership(address _newOwner) public onlyOwner {\n _transferOwnership(_newOwner);\n }\n\n /// @notice Forces an ownership transfer from any sender\n /// @param _newOwner New owner to transfer contract to\n /// @dev Ensure is called only from trusted internal code, no access control checks.\n function _transferOwnership(address _newOwner) internal {\n emit OwnerUpdated(_owner, _newOwner);\n\n _owner = _newOwner;\n\n if (_pendingOwner != address(0)) delete _pendingOwner;\n }\n\n /// @notice Initiates a two-step ownership transfer\n /// @param _newOwner The new owner address\n function safeTransferOwnership(address _newOwner) public onlyOwner {\n _pendingOwner = _newOwner;\n\n emit OwnerPending(_owner, _newOwner);\n }\n\n /// @notice Accepts an ownership transfer\n function acceptOwnership() public onlyPendingOwner {\n emit OwnerUpdated(_owner, msg.sender);\n\n _owner = _pendingOwner;\n\n delete _pendingOwner;\n }\n\n /// @notice Cancels a pending ownership transfer\n function cancelOwnershipTransfer() public onlyOwner {\n emit OwnerCanceled(_owner, _pendingOwner);\n\n delete _pendingOwner;\n }\n}\n"
},
"src/lib/proxy/ERC1967Proxy.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport { Proxy } from \"@openzeppelin/contracts/proxy/Proxy.sol\";\n\nimport { IERC1967Upgrade } from \"../interfaces/IERC1967Upgrade.sol\";\nimport { ERC1967Upgrade } from \"./ERC1967Upgrade.sol\";\n\n/// @title ERC1967Proxy\n/// @author Rohan Kulkarni\n/// @notice Modified from OpenZeppelin Contracts v4.7.3 (proxy/ERC1967/ERC1967Proxy.sol)\n/// - Inherits a modern, minimal ERC1967Upgrade\ncontract ERC1967Proxy is IERC1967Upgrade, Proxy, ERC1967Upgrade {\n /// ///\n /// CONSTRUCTOR ///\n /// ///\n\n /// @dev Initializes the proxy with an implementation contract and encoded function call\n /// @param _logic The implementation address\n /// @param _data The encoded function call\n constructor(address _logic, bytes memory _data) payable {\n _upgradeToAndCall(_logic, _data, false);\n }\n\n /// ///\n /// FUNCTIONS ///\n /// ///\n\n /// @dev The address of the current implementation\n function _implementation() internal view virtual override returns (address) {\n return ERC1967Upgrade._getImplementation();\n }\n}\n"
},
"src/manager/storage/ManagerStorageV1.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport { ManagerTypesV1 } from \"../types/ManagerTypesV1.sol\";\n\n/// @notice Manager Storage V1\n/// @author Rohan Kulkarni\n/// @notice The Manager storage contract\ncontract ManagerStorageV1 is ManagerTypesV1 {\n /// @notice If a contract has been registered as an upgrade\n /// @dev Base impl => Upgrade impl\n mapping(address => mapping(address => bool)) internal isUpgrade;\n\n /// @notice Registers deployed addresses\n /// @dev Token deployed address => Struct of all other DAO addresses\n mapping(address => DAOAddresses) internal daoAddressesByToken;\n}\n"
},
"src/manager/IManager.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport { IUUPS } from \"../lib/interfaces/IUUPS.sol\";\nimport { IOwnable } from \"../lib/interfaces/IOwnable.sol\";\n\n/// @title IManager\n/// @author Rohan Kulkarni\n/// @notice The external Manager events, errors, structs and functions\ninterface IManager is IUUPS, IOwnable {\n /// ///\n /// EVENTS ///\n /// ///\n\n /// @notice Emitted when a DAO is deployed\n /// @param token The ERC-721 token address\n /// @param metadata The metadata renderer address\n /// @param auction The auction address\n /// @param treasury The treasury address\n /// @param governor The governor address\n event DAODeployed(address token, address metadata, address auction, address treasury, address governor);\n\n /// @notice Emitted when an upgrade is registered by the Builder DAO\n /// @param baseImpl The base implementation address\n /// @param upgradeImpl The upgrade implementation address\n event UpgradeRegistered(address baseImpl, address upgradeImpl);\n\n /// @notice Emitted when an upgrade is unregistered by the Builder DAO\n /// @param baseImpl The base implementation address\n /// @param upgradeImpl The upgrade implementation address\n event UpgradeRemoved(address baseImpl, address upgradeImpl);\n\n /// ///\n /// ERRORS ///\n /// ///\n\n /// @dev Reverts if at least one founder is not provided upon deploy\n error FOUNDER_REQUIRED();\n\n /// ///\n /// STRUCTS ///\n /// ///\n\n /// @notice The founder parameters\n /// @param wallet The wallet address\n /// @param ownershipPct The percent ownership of the token\n /// @param vestExpiry The timestamp that vesting expires\n struct FounderParams {\n address wallet;\n uint256 ownershipPct;\n uint256 vestExpiry;\n }\n\n /// @notice The ERC-721 token parameters\n /// @param initStrings The encoded token name, symbol, collection description, collection image uri, renderer base uri\n struct TokenParams {\n bytes initStrings;\n }\n\n /// @notice The auction parameters\n /// @param reservePrice The reserve price of each auction\n /// @param duration The duration of each auction\n struct AuctionParams {\n uint256 reservePrice;\n uint256 duration;\n }\n\n /// @notice The governance parameters\n /// @param timelockDelay The time delay to execute a queued transaction\n /// @param votingDelay The time delay to vote on a created proposal\n /// @param votingPeriod The time period to vote on a proposal\n /// @param proposalThresholdBps The basis points of the token supply required to create a proposal\n /// @param quorumThresholdBps The basis points of the token supply required to reach quorum\n /// @param vetoer The address authorized to veto proposals (address(0) if none desired)\n struct GovParams {\n uint256 timelockDelay;\n uint256 votingDelay;\n uint256 votingPeriod;\n uint256 proposalThresholdBps;\n uint256 quorumThresholdBps;\n address vetoer;\n }\n\n /// ///\n /// FUNCTIONS ///\n /// ///\n\n /// @notice The token implementation address\n function tokenImpl() external view returns (address);\n\n /// @notice The metadata renderer implementation address\n function metadataImpl() external view returns (address);\n\n /// @notice The auction house implementation address\n function auctionImpl() external view returns (address);\n\n /// @notice The treasury implementation address\n function treasuryImpl() external view returns (address);\n\n /// @notice The governor implementation address\n function governorImpl() external view returns (address);\n\n /// @notice Deploys a DAO with custom token, auction, and governance settings\n /// @param founderParams The DAO founder(s)\n /// @param tokenParams The ERC-721 token settings\n /// @param auctionParams The auction settings\n /// @param govParams The governance settings\n function deploy(\n FounderParams[] calldata founderParams,\n TokenParams calldata tokenParams,\n AuctionParams calldata auctionParams,\n GovParams calldata govParams\n )\n external\n returns (\n address token,\n address metadataRenderer,\n address auction,\n address treasury,\n address governor\n );\n\n /// @notice A DAO's remaining contract addresses from its token address\n /// @param token The ERC-721 token address\n function getAddresses(address token)\n external\n returns (\n address metadataRenderer,\n address auction,\n address treasury,\n address governor\n );\n\n /// @notice If an implementation is registered by the Builder DAO as an optional upgrade\n /// @param baseImpl The base implementation address\n /// @param upgradeImpl The upgrade implementation address\n function isRegisteredUpgrade(address baseImpl, address upgradeImpl) external view returns (bool);\n\n /// @notice Called by the Builder DAO to offer opt-in implementation upgrades for all other DAOs\n /// @param baseImpl The base implementation address\n /// @param upgradeImpl The upgrade implementation address\n function registerUpgrade(address baseImpl, address upgradeImpl) external;\n\n /// @notice Called by the Builder DAO to remove an upgrade\n /// @param baseImpl The base implementation address\n /// @param upgradeImpl The upgrade implementation address\n function removeUpgrade(address baseImpl, address upgradeImpl) external;\n}\n"
},
"src/token/IToken.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport { IUUPS } from \"../lib/interfaces/IUUPS.sol\";\nimport { IERC721Votes } from \"../lib/interfaces/IERC721Votes.sol\";\nimport { IManager } from \"../manager/IManager.sol\";\nimport { TokenTypesV1 } from \"./types/TokenTypesV1.sol\";\n\n/// @title IToken\n/// @author Rohan Kulkarni\n/// @notice The external Token events, errors and functions\ninterface IToken is IUUPS, IERC721Votes, TokenTypesV1 {\n /// ///\n /// EVENTS ///\n /// ///\n\n /// @notice Emitted when a token is scheduled to be allocated\n /// @param baseTokenId The\n /// @param founderId The founder's id\n /// @param founder The founder's vesting details\n event MintScheduled(uint256 baseTokenId, uint256 founderId, Founder founder);\n\n /// ///\n /// ERRORS ///\n /// ///\n\n /// @dev Reverts if the founder ownership exceeds 100 percent\n error INVALID_FOUNDER_OWNERSHIP();\n\n /// @dev Reverts if the caller was not the auction contract\n error ONLY_AUCTION();\n\n /// @dev Reverts if no metadata was generated upon mint\n error NO_METADATA_GENERATED();\n\n /// @dev Reverts if the caller was not the contract manager\n error ONLY_MANAGER();\n\n /// ///\n /// FUNCTIONS ///\n /// ///\n\n /// @notice Initializes a DAO's ERC-721 token\n /// @param founders The founding members to receive vesting allocations\n /// @param initStrings The encoded token and metadata initialization strings\n /// @param metadataRenderer The token's metadata renderer\n /// @param auction The token's auction house\n function initialize(\n IManager.FounderParams[] calldata founders,\n bytes calldata initStrings,\n address metadataRenderer,\n address auction,\n address initialOwner\n ) external;\n\n /// @notice Mints tokens to the auction house for bidding and handles founder vesting\n function mint() external returns (uint256 tokenId);\n\n /// @notice Burns a token that did not see any bids\n /// @param tokenId The ERC-721 token id\n function burn(uint256 tokenId) external;\n\n /// @notice The URI for a token\n /// @param tokenId The ERC-721 token id\n function tokenURI(uint256 tokenId) external view returns (string memory);\n\n /// @notice The URI for the contract\n function contractURI() external view returns (string memory);\n\n /// @notice The number of founders\n function totalFounders() external view returns (uint256);\n\n /// @notice The founders total percent ownership\n function totalFounderOwnership() external view returns (uint256);\n\n /// @notice The vesting details of a founder\n /// @param founderId The founder id\n function getFounder(uint256 founderId) external view returns (Founder memory);\n\n /// @notice The vesting details of all founders\n function getFounders() external view returns (Founder[] memory);\n\n /// @notice The founder scheduled to receive the given token id\n /// NOTE: If a founder is returned, there's no guarantee they'll receive the token as vesting expiration is not considered\n /// @param tokenId The ERC-721 token id\n function getScheduledRecipient(uint256 tokenId) external view returns (Founder memory);\n\n /// @notice The total supply of tokens\n function totalSupply() external view returns (uint256);\n\n /// @notice The token's auction house\n function auction() external view returns (address);\n\n /// @notice The token's metadata renderer\n function metadataRenderer() external view returns (address);\n\n /// @notice The owner of the token and metadata renderer\n function owner() external view returns (address);\n\n /// @notice Callback called by auction on first auction started to transfer ownership to treasury from founder\n function onFirstAuctionStarted() external;\n}\n"
},
"src/token/metadata/interfaces/IBaseMetadata.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport { IUUPS } from \"../../../lib/interfaces/IUUPS.sol\";\n\n\n/// @title IBaseMetadata\n/// @author Rohan Kulkarni\n/// @notice The external Base Metadata errors and functions\ninterface IBaseMetadata is IUUPS {\n /// ///\n /// ERRORS ///\n /// ///\n\n /// @dev Reverts if the caller was not the contract manager\n error ONLY_MANAGER();\n\n /// ///\n /// FUNCTIONS ///\n /// ///\n\n /// @notice Initializes a DAO's token metadata renderer\n /// @param initStrings The encoded token and metadata initialization strings\n /// @param token The associated ERC-721 token address\n function initialize(\n bytes calldata initStrings,\n address token\n ) external;\n\n /// @notice Generates attributes for a token upon mint\n /// @param tokenId The ERC-721 token id\n function onMinted(uint256 tokenId) external returns (bool);\n\n /// @notice The token URI\n /// @param tokenId The ERC-721 token id\n function tokenURI(uint256 tokenId) external view returns (string memory);\n\n /// @notice The contract URI\n function contractURI() external view returns (string memory);\n\n /// @notice The associated ERC-721 token\n function token() external view returns (address);\n\n /// @notice Get metadata owner address\n function owner() external view returns (address);\n}\n"
},
"src/auction/IAuction.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport { IUUPS } from \"../lib/interfaces/IUUPS.sol\";\nimport { IOwnable } from \"../lib/interfaces/IOwnable.sol\";\nimport { IPausable } from \"../lib/interfaces/IPausable.sol\";\n\n/// @title IAuction\n/// @author Rohan Kulkarni\n/// @notice The external Auction events, errors, and functions\ninterface IAuction is IUUPS, IOwnable, IPausable {\n /// ///\n /// EVENTS ///\n /// ///\n\n /// @notice Emitted when a bid is placed\n /// @param tokenId The ERC-721 token id\n /// @param bidder The address of the bidder\n /// @param amount The amount of ETH\n /// @param extended If the bid extended the auction\n /// @param endTime The end time of the auction\n event AuctionBid(uint256 tokenId, address bidder, uint256 amount, bool extended, uint256 endTime);\n\n /// @notice Emitted when an auction is settled\n /// @param tokenId The ERC-721 token id of the settled auction\n /// @param winner The address of the winning bidder\n /// @param amount The amount of ETH raised from the winning bid\n event AuctionSettled(uint256 tokenId, address winner, uint256 amount);\n\n /// @notice Emitted when an auction is created\n /// @param tokenId The ERC-721 token id of the created auction\n /// @param startTime The start time of the created auction\n /// @param endTime The end time of the created auction\n event AuctionCreated(uint256 tokenId, uint256 startTime, uint256 endTime);\n\n /// @notice Emitted when the auction duration is updated\n /// @param duration The new auction duration\n event DurationUpdated(uint256 duration);\n\n /// @notice Emitted when the reserve price is updated\n /// @param reservePrice The new reserve price\n event ReservePriceUpdated(uint256 reservePrice);\n\n /// @notice Emitted when the min bid increment percentage is updated\n /// @param minBidIncrementPercentage The new min bid increment percentage\n event MinBidIncrementPercentageUpdated(uint256 minBidIncrementPercentage);\n\n /// @notice Emitted when the time buffer is updated\n /// @param timeBuffer The new time buffer\n event TimeBufferUpdated(uint256 timeBuffer);\n\n /// ///\n /// ERRORS ///\n /// ///\n\n /// @dev Reverts if a bid is placed for the wrong token\n error INVALID_TOKEN_ID();\n\n /// @dev Reverts if a bid is placed for an auction thats over\n error AUCTION_OVER();\n\n /// @dev Reverts if a bid is placed for an auction that hasn't started\n error AUCTION_NOT_STARTED();\n\n /// @dev Reverts if attempting to settle an active auction\n error AUCTION_ACTIVE();\n\n /// @dev Reverts if attempting to settle an auction that was already settled\n error AUCTION_SETTLED();\n\n /// @dev Reverts if a bid does not meet the reserve price\n error RESERVE_PRICE_NOT_MET();\n\n /// @dev Reverts if a bid does not meet the minimum bid\n error MINIMUM_BID_NOT_MET();\n\n /// @dev Reverts if the contract does not have enough ETH\n error INSOLVENT();\n\n /// @dev Reverts if the caller was not the contract manager\n error ONLY_MANAGER();\n\n /// @dev Thrown if the WETH contract throws a failure on transfer\n error FAILING_WETH_TRANSFER();\n\n /// @dev Thrown if the auction creation failed\n error AUCTION_CREATE_FAILED_TO_LAUNCH();\n\n /// ///\n /// FUNCTIONS ///\n /// ///\n\n /// @notice Initializes a DAO's auction house\n /// @param token The ERC-721 token address\n /// @param founder The founder responsible for starting the first auction\n /// @param treasury The treasury address where ETH will be sent\n /// @param duration The duration of each auction\n /// @param reservePrice The reserve price of each auction\n function initialize(\n address token,\n address founder,\n address treasury,\n uint256 duration,\n uint256 reservePrice\n ) external;\n\n /// @notice Creates a bid for the current token\n /// @param tokenId The ERC-721 token id\n function createBid(uint256 tokenId) external payable;\n\n /// @notice Settles the current auction and creates the next one\n function settleCurrentAndCreateNewAuction() external;\n\n /// @notice Settles the latest auction when the contract is paused\n function settleAuction() external;\n\n /// @notice Pauses the auction house\n function pause() external;\n\n /// @notice Unpauses the auction house\n function unpause() external;\n\n /// @notice The time duration of each auction\n function duration() external view returns (uint256);\n\n /// @notice The reserve price of each auction\n function reservePrice() external view returns (uint256);\n\n /// @notice The minimum amount of time to place a bid during an active auction\n function timeBuffer() external view returns (uint256);\n\n /// @notice The minimum percentage an incoming bid must raise the highest bid\n function minBidIncrement() external view returns (uint256);\n\n /// @notice Updates the time duration of each auction\n /// @param duration The new time duration\n function setDuration(uint256 duration) external;\n\n /// @notice Updates the reserve price of each auction\n /// @param reservePrice The new reserve price\n function setReservePrice(uint256 reservePrice) external;\n\n /// @notice Updates the time buffer of each auction\n /// @param timeBuffer The new time buffer\n function setTimeBuffer(uint256 timeBuffer) external;\n\n /// @notice Updates the minimum bid increment of each subsequent bid\n /// @param percentage The new percentage\n function setMinimumBidIncrement(uint256 percentage) external;\n\n /// @notice Get the address of the treasury\n function treasury() external returns (address);\n}\n"
},
"src/governance/treasury/ITreasury.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport { IOwnable } from \"../../lib/utils/Ownable.sol\";\nimport { IUUPS } from \"../../lib/interfaces/IUUPS.sol\";\n\n/// @title ITreasury\n/// @author Rohan Kulkarni\n/// @notice The external Treasury events, errors and functions\ninterface ITreasury is IUUPS, IOwnable {\n /// ///\n /// EVENTS ///\n /// ///\n\n /// @notice Emitted when a transaction is scheduled\n event TransactionScheduled(bytes32 proposalId, uint256 timestamp);\n\n /// @notice Emitted when a transaction is canceled\n event TransactionCanceled(bytes32 proposalId);\n\n /// @notice Emitted when a transaction is executed\n event TransactionExecuted(bytes32 proposalId, address[] targets, uint256[] values, bytes[] payloads);\n\n /// @notice Emitted when the transaction delay is updated\n event DelayUpdated(uint256 prevDelay, uint256 newDelay);\n\n /// @notice Emitted when the grace period is updated\n event GracePeriodUpdated(uint256 prevGracePeriod, uint256 newGracePeriod);\n\n /// ///\n /// ERRORS ///\n /// ///\n\n /// @dev Reverts if tx was already queued\n error PROPOSAL_ALREADY_QUEUED();\n\n /// @dev Reverts if tx was not queued\n error PROPOSAL_NOT_QUEUED();\n\n /// @dev Reverts if a tx isn't ready to execute\n /// @param proposalId The proposal id\n error EXECUTION_NOT_READY(bytes32 proposalId);\n\n /// @dev Reverts if a tx failed\n /// @param txIndex The index of the tx\n error EXECUTION_FAILED(uint256 txIndex);\n\n /// @dev Reverts if execution was attempted after the grace period\n error EXECUTION_EXPIRED();\n\n /// @dev Reverts if the caller was not the treasury itself\n error ONLY_TREASURY();\n\n /// @dev Reverts if the caller was not the contract manager\n error ONLY_MANAGER();\n\n /// ///\n /// FUNCTIONS ///\n /// ///\n\n /// @notice Initializes a DAO's treasury\n /// @param governor The governor address\n /// @param timelockDelay The time delay to execute a queued transaction\n function initialize(address governor, uint256 timelockDelay) external;\n\n /// @notice The timestamp that a proposal is valid to execute\n /// @param proposalId The proposal id\n function timestamp(bytes32 proposalId) external view returns (uint256);\n\n /// @notice If a proposal has been queued\n /// @param proposalId The proposal ids\n function isQueued(bytes32 proposalId) external view returns (bool);\n\n /// @notice If a proposal is ready to execute (does not consider if a proposal has expired)\n /// @param proposalId The proposal id\n function isReady(bytes32 proposalId) external view returns (bool);\n\n /// @notice If a proposal has expired to execute\n /// @param proposalId The proposal id\n function isExpired(bytes32 proposalId) external view returns (bool);\n\n /// @notice Schedules a proposal for execution\n /// @param proposalId The proposal id\n function queue(bytes32 proposalId) external returns (uint256 eta);\n\n /// @notice Removes a queued proposal\n /// @param proposalId The proposal id\n function cancel(bytes32 proposalId) external;\n\n /// @notice Executes a queued proposal\n /// @param targets The target addresses to call\n /// @param values The ETH values of each call\n /// @param calldatas The calldata of each call\n /// @param descriptionHash The hash of the description\n /// @param proposer The proposal creator\n function execute(\n address[] calldata targets,\n uint256[] calldata values,\n bytes[] calldata calldatas,\n bytes32 descriptionHash,\n address proposer\n ) external payable;\n\n /// @notice The time delay to execute a queued transaction\n function delay() external view returns (uint256);\n\n /// @notice The time period to execute a transaction\n function gracePeriod() external view returns (uint256);\n\n /// @notice Updates the time delay\n /// @param newDelay The new time delay\n function updateDelay(uint256 newDelay) external;\n\n /// @notice Updates the grace period\n /// @param newGracePeriod The grace period\n function updateGracePeriod(uint256 newGracePeriod) external;\n}\n"
},
"src/governance/governor/IGovernor.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport { IUUPS } from \"../../lib/interfaces/IUUPS.sol\";\nimport { IOwnable } from \"../../lib/utils/Ownable.sol\";\nimport { IEIP712 } from \"../../lib/utils/EIP712.sol\";\nimport { GovernorTypesV1 } from \"./types/GovernorTypesV1.sol\";\n\n/// @title IGovernor\n/// @author Rohan Kulkarni\n/// @notice The external Governor events, errors and functions\ninterface IGovernor is IUUPS, IOwnable, IEIP712, GovernorTypesV1 {\n /// ///\n /// EVENTS ///\n /// ///\n\n /// @notice Emitted when a proposal is created\n event ProposalCreated(\n bytes32 proposalId,\n address[] targets,\n uint256[] values,\n bytes[] calldatas,\n string description,\n bytes32 descriptionHash,\n Proposal proposal\n );\n\n /// @notice Emitted when a proposal is queued\n event ProposalQueued(bytes32 proposalId, uint256 eta);\n\n /// @notice Emitted when a proposal is executed\n /// @param proposalId The proposal id\n event ProposalExecuted(bytes32 proposalId);\n\n /// @notice Emitted when a proposal is canceled\n event ProposalCanceled(bytes32 proposalId);\n\n /// @notice Emitted when a proposal is vetoed\n event ProposalVetoed(bytes32 proposalId);\n\n /// @notice Emitted when a vote is casted for a proposal\n event VoteCast(address voter, bytes32 proposalId, uint256 support, uint256 weight, string reason);\n\n /// @notice Emitted when the governor's voting delay is updated\n event VotingDelayUpdated(uint256 prevVotingDelay, uint256 newVotingDelay);\n\n /// @notice Emitted when the governor's voting period is updated\n event VotingPeriodUpdated(uint256 prevVotingPeriod, uint256 newVotingPeriod);\n\n /// @notice Emitted when the basis points of the governor's proposal threshold is updated\n event ProposalThresholdBpsUpdated(uint256 prevBps, uint256 newBps);\n\n /// @notice Emitted when the basis points of the governor's quorum votes is updated\n event QuorumVotesBpsUpdated(uint256 prevBps, uint256 newBps);\n\n //// @notice Emitted when the governor's vetoer is updated\n event VetoerUpdated(address prevVetoer, address newVetoer);\n\n /// ///\n /// ERRORS ///\n /// ///\n\n error INVALID_PROPOSAL_THRESHOLD_BPS();\n\n error INVALID_QUORUM_THRESHOLD_BPS();\n\n error INVALID_VOTING_DELAY();\n\n error INVALID_VOTING_PERIOD();\n\n /// @dev Reverts if a proposal already exists\n /// @param proposalId The proposal id\n error PROPOSAL_EXISTS(bytes32 proposalId);\n\n /// @dev Reverts if a proposal isn't queued\n /// @param proposalId The proposal id\n error PROPOSAL_NOT_QUEUED(bytes32 proposalId);\n\n /// @dev Reverts if the proposer didn't specify a target address\n error PROPOSAL_TARGET_MISSING();\n\n /// @dev Reverts if the number of targets, values, and calldatas does not match\n error PROPOSAL_LENGTH_MISMATCH();\n\n /// @dev Reverts if a proposal didn't succeed\n error PROPOSAL_UNSUCCESSFUL();\n\n /// @dev Reverts if a proposal was already executed\n error PROPOSAL_ALREADY_EXECUTED();\n\n /// @dev Reverts if a specified proposal doesn't exist\n error PROPOSAL_DOES_NOT_EXIST();\n\n /// @dev Reverts if the proposer's voting weight is below the proposal threshold\n error BELOW_PROPOSAL_THRESHOLD();\n\n /// @dev Reverts if a vote was prematurely casted\n error VOTING_NOT_STARTED();\n\n /// @dev Reverts if the caller wasn't the vetoer\n error ONLY_VETOER();\n\n /// @dev Reverts if the caller already voted\n error ALREADY_VOTED();\n\n /// @dev Reverts if a proposal was attempted to be canceled incorrectly\n error INVALID_CANCEL();\n\n /// @dev Reverts if a vote was attempted to be casted incorrectly\n error INVALID_VOTE();\n\n /// @dev Reverts if the caller was not the contract manager\n error ONLY_MANAGER();\n\n /// ///\n /// FUNCTIONS ///\n /// ///\n\n /// @notice Initializes a DAO's governor\n /// @param treasury The DAO's treasury address\n /// @param token The DAO's governance token address\n /// @param vetoer The address eligible to veto proposals\n /// @param votingDelay The voting delay\n /// @param votingPeriod The voting period\n /// @param proposalThresholdBps The proposal threshold basis points\n /// @param quorumThresholdBps The quorum threshold basis points\n function initialize(\n address treasury,\n address token,\n address vetoer,\n uint256 votingDelay,\n uint256 votingPeriod,\n uint256 proposalThresholdBps,\n uint256 quorumThresholdBps\n ) external;\n\n /// @notice Creates a proposal\n /// @param targets The target addresses to call\n /// @param values The ETH values of each call\n /// @param calldatas The calldata of each call\n /// @param description The proposal description\n function propose(\n address[] memory targets,\n uint256[] memory values,\n bytes[] memory calldatas,\n string memory description\n ) external returns (bytes32);\n\n /// @notice Casts a vote\n /// @param proposalId The proposal id\n /// @param support The support value (0 = Against, 1 = For, 2 = Abstain)\n function castVote(bytes32 proposalId, uint256 support) external returns (uint256);\n\n /// @notice Casts a vote with a reason\n /// @param proposalId The proposal id\n /// @param support The support value (0 = Against, 1 = For, 2 = Abstain)\n /// @param reason The vote reason\n function castVoteWithReason(\n bytes32 proposalId,\n uint256 support,\n string memory reason\n ) external returns (uint256);\n\n /// @notice Casts a signed vote\n /// @param voter The voter address\n /// @param proposalId The proposal id\n /// @param support The support value (0 = Against, 1 = For, 2 = Abstain)\n /// @param deadline The signature deadline\n /// @param v The 129th byte and chain id of the signature\n /// @param r The first 64 bytes of the signature\n /// @param s Bytes 64-128 of the signature\n function castVoteBySig(\n address voter,\n bytes32 proposalId,\n uint256 support,\n uint256 deadline,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) external returns (uint256);\n\n /// @notice Queues a proposal\n /// @param proposalId The proposal id\n function queue(bytes32 proposalId) external returns (uint256 eta);\n\n /// @notice Executes a proposal\n /// @param targets The target addresses to call\n /// @param values The ETH values of each call\n /// @param calldatas The calldata of each call\n /// @param descriptionHash The hash of the description\n /// @param proposer The proposal creator\n function execute(\n address[] memory targets,\n uint256[] memory values,\n bytes[] memory calldatas,\n bytes32 descriptionHash,\n address proposer\n ) external payable returns (bytes32);\n\n /// @notice Cancels a proposal\n /// @param proposalId The proposal id\n function cancel(bytes32 proposalId) external;\n\n /// @notice Vetoes a proposal\n /// @param proposalId The proposal id\n function veto(bytes32 proposalId) external;\n\n /// @notice The state of a proposal\n /// @param proposalId The proposal id\n function state(bytes32 proposalId) external view returns (ProposalState);\n\n /// @notice The voting weight of an account at a timestamp\n /// @param account The account address\n /// @param timestamp The specific timestamp\n function getVotes(address account, uint256 timestamp) external view returns (uint256);\n\n /// @notice The current number of votes required to submit a proposal\n function proposalThreshold() external view returns (uint256);\n\n /// @notice The current number of votes required to be in favor of a proposal in order to reach quorum\n function quorum() external view returns (uint256);\n\n /// @notice The details of a proposal\n /// @param proposalId The proposal id\n function getProposal(bytes32 proposalId) external view returns (Proposal memory);\n\n /// @notice The timestamp when voting starts for a proposal\n /// @param proposalId The proposal id\n function proposalSnapshot(bytes32 proposalId) external view returns (uint256);\n\n /// @notice The timestamp when voting ends for a proposal\n /// @param proposalId The proposal id\n function proposalDeadline(bytes32 proposalId) external view returns (uint256);\n\n /// @notice The vote counts for a proposal\n /// @param proposalId The proposal id\n function proposalVotes(bytes32 proposalId)\n external\n view\n returns (\n uint256 againstVotes,\n uint256 forVotes,\n uint256 abstainVotes\n );\n\n /// @notice The timestamp valid to execute a proposal\n /// @param proposalId The proposal id\n function proposalEta(bytes32 proposalId) external view returns (uint256);\n\n /// @notice The minimum basis points of the total token supply required to submit a proposal\n function proposalThresholdBps() external view returns (uint256);\n\n /// @notice The minimum basis points of the total token supply required to reach quorum\n function quorumThresholdBps() external view returns (uint256);\n\n /// @notice The amount of time until voting begins after a proposal is created\n function votingDelay() external view returns (uint256);\n\n /// @notice The amount of time to vote on a proposal\n function votingPeriod() external view returns (uint256);\n\n /// @notice The address eligible to veto any proposal (address(0) if burned)\n function vetoer() external view returns (address);\n\n /// @notice The address of the governance token\n function token() external view returns (address);\n\n /// @notice The address of the DAO treasury\n function treasury() external view returns (address);\n\n /// @notice Updates the voting delay\n /// @param newVotingDelay The new voting delay\n function updateVotingDelay(uint256 newVotingDelay) external;\n\n /// @notice Updates the voting period\n /// @param newVotingPeriod The new voting period\n function updateVotingPeriod(uint256 newVotingPeriod) external;\n\n /// @notice Updates the minimum proposal threshold\n /// @param newProposalThresholdBps The new proposal threshold basis points\n function updateProposalThresholdBps(uint256 newProposalThresholdBps) external;\n\n /// @notice Updates the minimum quorum threshold\n /// @param newQuorumVotesBps The new quorum votes basis points\n function updateQuorumThresholdBps(uint256 newQuorumVotesBps) external;\n\n /// @notice Updates the vetoer\n /// @param newVetoer The new vetoer addresss\n function updateVetoer(address newVetoer) external;\n\n /// @notice Burns the vetoer\n function burnVetoer() external;\n\n /// @notice The EIP-712 typehash to vote with a signature\n function VOTE_TYPEHASH() external view returns (bytes32);\n}\n"
},
"src/lib/interfaces/IUUPS.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.16;\n\nimport { IERC1822Proxiable } from \"@openzeppelin/contracts/interfaces/draft-IERC1822.sol\";\nimport { IERC1967Upgrade } from \"./IERC1967Upgrade.sol\";\n\n/// @title IUUPS\n/// @author Rohan Kulkarni\n/// @notice The external UUPS errors and functions\ninterface IUUPS is IERC1967Upgrade, IERC1822Proxiable {\n /// ///\n /// ERRORS ///\n /// ///\n\n /// @dev Reverts if not called directly\n error ONLY_CALL();\n\n /// @dev Reverts if not called via delegatecall\n error ONLY_DELEGATECALL();\n\n /// @dev Reverts if not called via proxy\n error ONLY_PROXY();\n\n /// ///\n /// FUNCTIONS ///\n /// ///\n\n /// @notice Upgrades to an implementation\n /// @param newImpl The new implementation address\n function upgradeTo(address newImpl) external;\n\n /// @notice Upgrades to an implementation with an additional function call\n /// @param newImpl The new implementation address\n /// @param data The encoded function call\n function upgradeToAndCall(address newImpl, bytes memory data) external payable;\n}\n"
},
"src/lib/proxy/ERC1967Upgrade.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport { IERC1822Proxiable } from \"@openzeppelin/contracts/interfaces/draft-IERC1822.sol\";\nimport { StorageSlot } from \"@openzeppelin/contracts/utils/StorageSlot.sol\";\n\nimport { IERC1967Upgrade } from \"../interfaces/IERC1967Upgrade.sol\";\nimport { Address } from \"../utils/Address.sol\";\n\n/// @title ERC1967Upgrade\n/// @author Rohan Kulkarni\n/// @notice Modified from OpenZeppelin Contracts v4.7.3 (proxy/ERC1967/ERC1967Upgrade.sol)\n/// - Uses custom errors declared in IERC1967Upgrade\n/// - Removes ERC1967 admin and beacon support\nabstract contract ERC1967Upgrade is IERC1967Upgrade {\n /// ///\n /// CONSTANTS ///\n /// ///\n\n /// @dev bytes32(uint256(keccak256('eip1967.proxy.rollback')) - 1)\n bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;\n\n /// @dev bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1)\n bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n /// ///\n /// FUNCTIONS ///\n /// ///\n\n /// @dev Upgrades to an implementation with security checks for UUPS proxies and an additional function call\n /// @param _newImpl The new implementation address\n /// @param _data The encoded function call\n function _upgradeToAndCallUUPS(\n address _newImpl,\n bytes memory _data,\n bool _forceCall\n ) internal {\n if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {\n _setImplementation(_newImpl);\n } else {\n try IERC1822Proxiable(_newImpl).proxiableUUID() returns (bytes32 slot) {\n if (slot != _IMPLEMENTATION_SLOT) revert UNSUPPORTED_UUID();\n } catch {\n revert ONLY_UUPS();\n }\n\n _upgradeToAndCall(_newImpl, _data, _forceCall);\n }\n }\n\n /// @dev Upgrades to an implementation with an additional function call\n /// @param _newImpl The new implementation address\n /// @param _data The encoded function call\n function _upgradeToAndCall(\n address _newImpl,\n bytes memory _data,\n bool _forceCall\n ) internal {\n _upgradeTo(_newImpl);\n\n if (_data.length > 0 || _forceCall) {\n Address.functionDelegateCall(_newImpl, _data);\n }\n }\n\n /// @dev Performs an implementation upgrade\n /// @param _newImpl The new implementation address\n function _upgradeTo(address _newImpl) internal {\n _setImplementation(_newImpl);\n\n emit Upgraded(_newImpl);\n }\n\n /// @dev Stores the address of an implementation\n /// @param _impl The implementation address\n function _setImplementation(address _impl) private {\n if (!Address.isContract(_impl)) revert INVALID_UPGRADE(_impl);\n\n StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = _impl;\n }\n\n /// @dev The address of the current implementation\n function _getImplementation() internal view returns (address) {\n return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n }\n}\n"
},
"src/lib/interfaces/IOwnable.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\n/// @title IOwnable\n/// @author Rohan Kulkarni\n/// @notice The external Ownable events, errors, and functions\ninterface IOwnable {\n /// ///\n /// EVENTS ///\n /// ///\n\n /// @notice Emitted when ownership has been updated\n /// @param prevOwner The previous owner address\n /// @param newOwner The new owner address\n event OwnerUpdated(address indexed prevOwner, address indexed newOwner);\n\n /// @notice Emitted when an ownership transfer is pending\n /// @param owner The current owner address\n /// @param pendingOwner The pending new owner address\n event OwnerPending(address indexed owner, address indexed pendingOwner);\n\n /// @notice Emitted when a pending ownership transfer has been canceled\n /// @param owner The current owner address\n /// @param canceledOwner The canceled owner address\n event OwnerCanceled(address indexed owner, address indexed canceledOwner);\n\n /// ///\n /// ERRORS ///\n /// ///\n\n /// @dev Reverts if an unauthorized user calls an owner function\n error ONLY_OWNER();\n\n /// @dev Reverts if an unauthorized user calls a pending owner function\n error ONLY_PENDING_OWNER();\n\n /// ///\n /// FUNCTIONS ///\n /// ///\n\n /// @notice The address of the owner\n function owner() external view returns (address);\n\n /// @notice The address of the pending owner\n function pendingOwner() external view returns (address);\n\n /// @notice Forces an ownership transfer\n /// @param newOwner The new owner address\n function transferOwnership(address newOwner) external;\n\n /// @notice Initiates a two-step ownership transfer\n /// @param newOwner The new owner address\n function safeTransferOwnership(address newOwner) external;\n\n /// @notice Accepts an ownership transfer\n function acceptOwnership() external;\n\n /// @notice Cancels a pending ownership transfer\n function cancelOwnershipTransfer() external;\n}\n"
},
"src/lib/utils/Initializable.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport { IInitializable } from \"../interfaces/IInitializable.sol\";\nimport { Address } from \"../utils/Address.sol\";\n\n/// @title Initializable\n/// @author Rohan Kulkarni\n/// @notice Modified from OpenZeppelin Contracts v4.7.3 (proxy/utils/Initializable.sol)\n/// - Uses custom errors declared in IInitializable\nabstract contract Initializable is IInitializable {\n /// ///\n /// STORAGE ///\n /// ///\n\n /// @dev Indicates the contract has been initialized\n uint8 internal _initialized;\n\n /// @dev Indicates the contract is being initialized\n bool internal _initializing;\n\n /// ///\n /// MODIFIERS ///\n /// ///\n\n /// @dev Ensures an initialization function is only called within an `initializer` or `reinitializer` function\n modifier onlyInitializing() {\n if (!_initializing) revert NOT_INITIALIZING();\n _;\n }\n\n /// @dev Enables initializing upgradeable contracts\n modifier initializer() {\n bool isTopLevelCall = !_initializing;\n\n if ((!isTopLevelCall || _initialized != 0) && (Address.isContract(address(this)) || _initialized != 1)) revert ALREADY_INITIALIZED();\n\n _initialized = 1;\n\n if (isTopLevelCall) {\n _initializing = true;\n }\n\n _;\n\n if (isTopLevelCall) {\n _initializing = false;\n\n emit Initialized(1);\n }\n }\n\n /// @dev Enables initializer versioning\n /// @param _version The version to set\n modifier reinitializer(uint8 _version) {\n if (_initializing || _initialized >= _version) revert ALREADY_INITIALIZED();\n\n _initialized = _version;\n\n _initializing = true;\n\n _;\n\n _initializing = false;\n\n emit Initialized(_version);\n }\n\n /// ///\n /// FUNCTIONS ///\n /// ///\n\n /// @dev Prevents future initialization\n function _disableInitializers() internal virtual {\n if (_initializing) revert INITIALIZING();\n\n if (_initialized < type(uint8).max) {\n _initialized = type(uint8).max;\n\n emit Initialized(type(uint8).max);\n }\n }\n}\n"
},
"node_modules/@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"
},
"src/lib/interfaces/IERC1967Upgrade.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\n/// @title IERC1967Upgrade\n/// @author Rohan Kulkarni\n/// @notice The external ERC1967Upgrade events and errors\ninterface IERC1967Upgrade {\n /// ///\n /// EVENTS ///\n /// ///\n\n /// @notice Emitted when the implementation is upgraded\n /// @param impl The address of the implementation\n event Upgraded(address impl);\n\n /// ///\n /// ERRORS ///\n /// ///\n\n /// @dev Reverts if an implementation is an invalid upgrade\n /// @param impl The address of the invalid implementation\n error INVALID_UPGRADE(address impl);\n\n /// @dev Reverts if an implementation upgrade is not stored at the storage slot of the original\n error UNSUPPORTED_UUID();\n\n /// @dev Reverts if an implementation does not support ERC1822 proxiableUUID()\n error ONLY_UUPS();\n}\n"
},
"src/manager/types/ManagerTypesV1.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\n/// @title ManagerTypesV1\n/// @author Iain Nash & Rohan Kulkarni\n/// @notice The external Base Metadata errors and functions\ninterface ManagerTypesV1 {\n /// @notice Stores deployed addresses for a given token's DAO\n struct DAOAddresses {\n /// @notice Address for deployed metadata contract\n address metadata;\n /// @notice Address for deployed auction contract\n address auction;\n /// @notice Address for deployed treasury contract\n address treasury;\n /// @notice Address for deployed governor contract\n address governor;\n }\n}"
},
"src/lib/interfaces/IERC721Votes.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport { IERC721 } from \"./IERC721.sol\";\nimport { IEIP712 } from \"./IEIP712.sol\";\n\n/// @title IERC721Votes\n/// @author Rohan Kulkarni\n/// @notice The external ERC721Votes events, errors, and functions\ninterface IERC721Votes is IERC721, IEIP712 {\n /// ///\n /// EVENTS ///\n /// ///\n\n /// @notice Emitted when an account changes their delegate\n event DelegateChanged(address indexed delegator, address indexed from, address indexed to);\n\n /// @notice Emitted when a delegate's number of votes is updated\n event DelegateVotesChanged(address indexed delegate, uint256 prevTotalVotes, uint256 newTotalVotes);\n\n /// ///\n /// ERRORS ///\n /// ///\n\n /// @dev Reverts if the timestamp provided isn't in the past\n error INVALID_TIMESTAMP();\n\n /// ///\n /// STRUCTS ///\n /// ///\n\n /// @notice The checkpoint data type\n /// @param timestamp The recorded timestamp\n /// @param votes The voting weight\n struct Checkpoint {\n uint64 timestamp;\n uint192 votes;\n }\n\n /// ///\n /// FUNCTIONS ///\n /// ///\n\n /// @notice The current number of votes for an account\n /// @param account The account address\n function getVotes(address account) external view returns (uint256);\n\n /// @notice The number of votes for an account at a past timestamp\n /// @param account The account address\n /// @param timestamp The past timestamp\n function getPastVotes(address account, uint256 timestamp) external view returns (uint256);\n\n /// @notice The delegate for an account\n /// @param account The account address\n function delegates(address account) external view returns (address);\n\n /// @notice Delegates votes to an account\n /// @param to The address delegating votes to\n function delegate(address to) external;\n\n /// @notice Delegates votes from a signer to an account\n /// @param from The address delegating votes from\n /// @param to The address delegating votes to\n /// @param deadline The signature deadline\n /// @param v The 129th byte and chain id of the signature\n /// @param r The first 64 bytes of the signature\n /// @param s Bytes 64-128 of the signature\n function delegateBySig(\n address from,\n address to,\n uint256 deadline,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) external;\n}\n"
},
"src/token/types/TokenTypesV1.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport { IBaseMetadata } from \"../metadata/interfaces/IBaseMetadata.sol\";\n\n/// @title TokenTypesV1\n/// @author Rohan Kulkarni\n/// @notice The Token custom data types\ninterface TokenTypesV1 {\n /// @notice The settings type\n /// @param auction The DAO auction house\n /// @param totalSupply The number of active tokens\n /// @param numFounders The number of vesting recipients\n /// @param metadatarenderer The token metadata renderer\n /// @param mintCount The number of minted tokens\n /// @param totalPercentage The total percentage owned by founders\n struct Settings {\n address auction;\n uint88 totalSupply;\n uint8 numFounders;\n IBaseMetadata metadataRenderer;\n uint88 mintCount;\n uint8 totalOwnership;\n }\n\n /// @notice The founder type\n /// @param wallet The address where tokens are sent\n /// @param ownershipPct The percentage of token ownership\n /// @param vestExpiry The timestamp when vesting ends\n struct Founder {\n address wallet;\n uint8 ownershipPct;\n uint32 vestExpiry;\n }\n}\n"
},
"src/lib/interfaces/IPausable.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\n/// @title IPausable\n/// @author Rohan Kulkarni\n/// @notice The external Pausable events, errors, and functions\ninterface IPausable {\n /// ///\n /// EVENTS ///\n /// ///\n\n /// @notice Emitted when the contract is paused\n /// @param user The address that paused the contract\n event Paused(address user);\n\n /// @notice Emitted when the contract is unpaused\n /// @param user The address that unpaused the contract\n event Unpaused(address user);\n\n /// ///\n /// ERRORS ///\n /// ///\n\n /// @dev Reverts if called when the contract is paused\n error PAUSED();\n\n /// @dev Reverts if called when the contract is unpaused\n error UNPAUSED();\n\n /// ///\n /// FUNCTIONS ///\n /// ///\n\n /// @notice If the contract is paused\n function paused() external view returns (bool);\n}\n"
},
"src/lib/utils/EIP712.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport { IEIP712 } from \"../interfaces/IEIP712.sol\";\nimport { Initializable } from \"../utils/Initializable.sol\";\n\n/// @title EIP712\n/// @author Rohan Kulkarni\n/// @notice Modified from OpenZeppelin Contracts v4.7.3 (utils/cryptography/draft-EIP712Upgradeable.sol)\n/// - Uses custom errors declared in IEIP712\n/// - Caches `INITIAL_CHAIN_ID` and `INITIAL_DOMAIN_SEPARATOR` upon initialization\n/// - Adds mapping for account nonces\nabstract contract EIP712 is IEIP712, Initializable {\n /// ///\n /// CONSTANTS ///\n /// ///\n\n /// @dev The EIP-712 domain typehash\n bytes32 internal constant DOMAIN_TYPEHASH = keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\");\n\n /// ///\n /// STORAGE ///\n /// ///\n\n /// @notice The hash of the EIP-712 domain name\n bytes32 internal HASHED_NAME;\n\n /// @notice The hash of the EIP-712 domain version\n bytes32 internal HASHED_VERSION;\n\n /// @notice The domain separator computed upon initialization\n bytes32 internal INITIAL_DOMAIN_SEPARATOR;\n\n /// @notice The chain id upon initialization\n uint256 internal INITIAL_CHAIN_ID;\n\n /// @notice The account nonces\n /// @dev Account => Nonce\n mapping(address => uint256) internal nonces;\n\n /// ///\n /// FUNCTIONS ///\n /// ///\n\n /// @dev Initializes EIP-712 support\n /// @param _name The EIP-712 domain name\n /// @param _version The EIP-712 domain version\n function __EIP712_init(string memory _name, string memory _version) internal onlyInitializing {\n HASHED_NAME = keccak256(bytes(_name));\n HASHED_VERSION = keccak256(bytes(_version));\n\n INITIAL_CHAIN_ID = block.chainid;\n INITIAL_DOMAIN_SEPARATOR = _computeDomainSeparator();\n }\n\n /// @notice The current nonce for an account\n /// @param _account The account address\n function nonce(address _account) external view returns (uint256) {\n return nonces[_account];\n }\n\n /// @notice The EIP-712 domain separator\n function DOMAIN_SEPARATOR() public view returns (bytes32) {\n return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : _computeDomainSeparator();\n }\n\n /// @dev Computes the EIP-712 domain separator\n function _computeDomainSeparator() private view returns (bytes32) {\n return keccak256(abi.encode(DOMAIN_TYPEHASH, HASHED_NAME, HASHED_VERSION, block.chainid, address(this)));\n }\n}\n"
},
"src/governance/governor/types/GovernorTypesV1.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport { Token } from \"../../../token/Token.sol\";\nimport { Treasury } from \"../../treasury/Treasury.sol\";\n\n/// @title GovernorTypesV1\n/// @author Rohan Kulkarni\n/// @notice The Governor custom data types\ninterface GovernorTypesV1 {\n /// @notice The governor settings\n /// @param token The DAO governance token\n /// @param proposalThresholdBps The basis points of the token supply required to create a proposal\n /// @param quorumThresholdBps The basis points of the token supply required to reach quorum\n /// @param treasury The DAO treasury\n /// @param votingDelay The time delay to vote on a created proposal\n /// @param votingPeriod The time period to vote on a proposal\n /// @param vetoer The address with the ability to veto proposals\n struct Settings {\n Token token;\n uint16 proposalThresholdBps;\n uint16 quorumThresholdBps;\n Treasury treasury;\n uint48 votingDelay;\n uint48 votingPeriod;\n address vetoer;\n }\n\n /// @notice A governance proposal\n /// @param proposer The proposal creator\n /// @param timeCreated The timestamp that the proposal was created\n /// @param againstVotes The number of votes against\n /// @param forVotes The number of votes in favor\n /// @param abstainVotes The number of votes abstained\n /// @param voteStart The timestamp that voting starts\n /// @param voteEnd The timestamp that voting ends\n /// @param proposalThreshold The proposal threshold when the proposal was created\n /// @param quorumVotes The quorum threshold when the proposal was created\n /// @param executed If the proposal was executed\n /// @param canceled If the proposal was canceled\n /// @param vetoed If the proposal was vetoed\n struct Proposal {\n address proposer;\n uint32 timeCreated;\n uint32 againstVotes;\n uint32 forVotes;\n uint32 abstainVotes;\n uint32 voteStart;\n uint32 voteEnd;\n uint32 proposalThreshold;\n uint32 quorumVotes;\n bool executed;\n bool canceled;\n bool vetoed;\n }\n\n /// @notice The proposal state type\n enum ProposalState {\n Pending,\n Active,\n Canceled,\n Defeated,\n Succeeded,\n Queued,\n Expired,\n Executed,\n Vetoed\n }\n}\n"
},
"node_modules/@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"
},
"node_modules/@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"
},
"src/lib/utils/Address.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\n/// @title EIP712\n/// @author Rohan Kulkarni\n/// @notice Modified from OpenZeppelin Contracts v4.7.3 (utils/Address.sol)\n/// - Uses custom errors `INVALID_TARGET()` & `DELEGATE_CALL_FAILED()`\n/// - Adds util converting address to bytes32\nlibrary Address {\n /// ///\n /// ERRORS ///\n /// ///\n\n /// @dev Reverts if the target of a delegatecall is not a contract\n error INVALID_TARGET();\n\n /// @dev Reverts if a delegatecall has failed\n error DELEGATE_CALL_FAILED();\n\n /// ///\n /// FUNCTIONS ///\n /// ///\n\n /// @dev Utility to convert an address to bytes32\n function toBytes32(address _account) internal pure returns (bytes32) {\n return bytes32(uint256(uint160(_account)) << 96);\n }\n\n /// @dev If an address is a contract\n function isContract(address _account) internal view returns (bool rv) {\n assembly {\n rv := gt(extcodesize(_account), 0)\n }\n }\n\n /// @dev Performs a delegatecall on an address\n function functionDelegateCall(address _target, bytes memory _data) internal returns (bytes memory) {\n if (!isContract(_target)) revert INVALID_TARGET();\n\n (bool success, bytes memory returndata) = _target.delegatecall(_data);\n\n return verifyCallResult(success, returndata);\n }\n\n /// @dev Verifies a delegatecall was successful\n function verifyCallResult(bool _success, bytes memory _returndata) internal pure returns (bytes memory) {\n if (_success) {\n return _returndata;\n } else {\n if (_returndata.length > 0) {\n assembly {\n let returndata_size := mload(_returndata)\n\n revert(add(32, _returndata), returndata_size)\n }\n } else {\n revert DELEGATE_CALL_FAILED();\n }\n }\n }\n}\n"
},
"src/lib/interfaces/IInitializable.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\n/// @title IInitializable\n/// @author Rohan Kulkarni\n/// @notice The external Initializable events and errors\ninterface IInitializable {\n /// ///\n /// EVENTS ///\n /// ///\n\n /// @notice Emitted when the contract has been initialized or reinitialized\n event Initialized(uint256 version);\n\n /// ///\n /// ERRORS ///\n /// ///\n\n /// @dev Reverts if incorrectly initialized with address(0)\n error ADDRESS_ZERO();\n\n /// @dev Reverts if disabling initializers during initialization\n error INITIALIZING();\n\n /// @dev Reverts if calling an initialization function outside of initialization\n error NOT_INITIALIZING();\n\n /// @dev Reverts if reinitializing incorrectly\n error ALREADY_INITIALIZED();\n}\n"
},
"src/lib/interfaces/IERC721.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\n/// @title IERC721\n/// @author Rohan Kulkarni\n/// @notice The external ERC721 events, errors, and functions\ninterface IERC721 {\n /// ///\n /// EVENTS ///\n /// ///\n\n /// @notice Emitted when a token is transferred from sender to recipient\n /// @param from The sender address\n /// @param to The recipient address\n /// @param tokenId The ERC-721 token id\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\n\n /// @notice Emitted when an owner approves an account to manage a token\n /// @param owner The owner address\n /// @param approved The account address\n /// @param tokenId The ERC-721 token id\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\n\n /// @notice Emitted when an owner sets an approval for a spender to manage all tokens\n /// @param owner The owner address\n /// @param operator The spender address\n /// @param approved If the approval is being set or removed\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\n\n /// ///\n /// ERRORS ///\n /// ///\n\n /// @dev Reverts if a caller is not authorized to approve or transfer a token\n error INVALID_APPROVAL();\n\n /// @dev Reverts if a transfer is called with the incorrect token owner\n error INVALID_OWNER();\n\n /// @dev Reverts if a transfer is attempted to address(0)\n error INVALID_RECIPIENT();\n\n /// @dev Reverts if an existing token is called to be minted\n error ALREADY_MINTED();\n\n /// @dev Reverts if a non-existent token is called to be burned\n error NOT_MINTED();\n\n /// ///\n /// FUNCTIONS ///\n /// ///\n\n /// @notice The number of tokens owned\n /// @param owner The owner address\n function balanceOf(address owner) external view returns (uint256);\n\n /// @notice The owner of a token\n /// @param tokenId The ERC-721 token id\n function ownerOf(uint256 tokenId) external view returns (address);\n\n /// @notice The account approved to manage a token\n /// @param tokenId The ERC-721 token id\n function getApproved(uint256 tokenId) external view returns (address);\n\n /// @notice If an operator is authorized to manage all of an owner's tokens\n /// @param owner The owner address\n /// @param operator The operator address\n function isApprovedForAll(address owner, address operator) external view returns (bool);\n\n /// @notice Authorizes an account to manage a token\n /// @param to The account address\n /// @param tokenId The ERC-721 token id\n function approve(address to, uint256 tokenId) external;\n\n /// @notice Authorizes an account to manage all tokens\n /// @param operator The account address\n /// @param approved If permission is being given or removed\n function setApprovalForAll(address operator, bool approved) external;\n\n /// @notice Safe transfers a token from sender to recipient with additional data\n /// @param from The sender address\n /// @param to The recipient address\n /// @param tokenId The ERC-721 token id\n /// @param data The additional data sent in the call to the recipient\n function safeTransferFrom(\n address from,\n address to,\n uint256 tokenId,\n bytes calldata data\n ) external;\n\n /// @notice Safe transfers a token from sender to recipient\n /// @param from The sender address\n /// @param to The recipient address\n /// @param tokenId The ERC-721 token id\n function safeTransferFrom(\n address from,\n address to,\n uint256 tokenId\n ) external;\n\n /// @notice Transfers a token from sender to recipient\n /// @param from The sender address\n /// @param to The recipient address\n /// @param tokenId The ERC-721 token id\n function transferFrom(\n address from,\n address to,\n uint256 tokenId\n ) external;\n}\n"
},
"src/lib/interfaces/IEIP712.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\n/// @title IEIP712\n/// @author Rohan Kulkarni\n/// @notice The external EIP712 errors and functions\ninterface IEIP712 {\n /// ///\n /// ERRORS ///\n /// ///\n\n /// @dev Reverts if the deadline has passed to submit a signature\n error EXPIRED_SIGNATURE();\n\n /// @dev Reverts if the recovered signature is invalid\n error INVALID_SIGNATURE();\n\n /// ///\n /// FUNCTIONS ///\n /// ///\n\n /// @notice The sig nonce for an account\n /// @param account The account address\n function nonce(address account) external view returns (uint256);\n\n /// @notice The EIP-712 domain separator\n function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n"
},
"src/token/Token.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport { UUPS } from \"../lib/proxy/UUPS.sol\";\nimport { ReentrancyGuard } from \"../lib/utils/ReentrancyGuard.sol\";\nimport { ERC721Votes } from \"../lib/token/ERC721Votes.sol\";\nimport { ERC721 } from \"../lib/token/ERC721.sol\";\nimport { Ownable } from \"../lib/utils/Ownable.sol\";\n\nimport { TokenStorageV1 } from \"./storage/TokenStorageV1.sol\";\nimport { IBaseMetadata } from \"./metadata/interfaces/IBaseMetadata.sol\";\nimport { IManager } from \"../manager/IManager.sol\";\nimport { IAuction } from \"../auction/IAuction.sol\";\nimport { IToken } from \"./IToken.sol\";\n\n/// @title Token\n/// @author Rohan Kulkarni\n/// @notice A DAO's ERC-721 governance token\ncontract Token is IToken, UUPS, Ownable, ReentrancyGuard, ERC721Votes, TokenStorageV1 {\n /// ///\n /// IMMUTABLES ///\n /// ///\n\n /// @notice The contract upgrade manager\n IManager private immutable manager;\n\n /// ///\n /// CONSTRUCTOR ///\n /// ///\n\n /// @param _manager The contract upgrade manager address\n constructor(address _manager) payable initializer {\n manager = IManager(_manager);\n }\n\n /// ///\n /// INITIALIZER ///\n /// ///\n\n /// @notice Initializes a DAO's ERC-721 token contract\n /// @param _founders The DAO founders\n /// @param _initStrings The encoded token and metadata initialization strings\n /// @param _metadataRenderer The token's metadata renderer\n /// @param _auction The token's auction house\n /// @param _initialOwner The initial owner of the token\n function initialize(\n IManager.FounderParams[] calldata _founders,\n bytes calldata _initStrings,\n address _metadataRenderer,\n address _auction,\n address _initialOwner\n ) external initializer {\n // Ensure the caller is the contract manager\n if (msg.sender != address(manager)) {\n revert ONLY_MANAGER();\n }\n\n // Initialize the reentrancy guard\n __ReentrancyGuard_init();\n\n // Setup ownable\n __Ownable_init(_initialOwner);\n\n // Store the founders and compute their allocations\n _addFounders(_founders);\n\n // Decode the token name and symbol\n (string memory _name, string memory _symbol, , , , ) = abi.decode(_initStrings, (string, string, string, string, string, string));\n\n // Initialize the ERC-721 token\n __ERC721_init(_name, _symbol);\n\n // Store the metadata renderer and auction house\n settings.metadataRenderer = IBaseMetadata(_metadataRenderer);\n settings.auction = _auction;\n }\n\n /// @notice Called by the auction upon the first unpause / token mint to transfer ownership from founder to treasury\n /// @dev Only callable by the auction contract\n function onFirstAuctionStarted() external override {\n if (msg.sender != settings.auction) {\n revert ONLY_AUCTION();\n }\n\n // Force transfer ownership to the treasury\n _transferOwnership(IAuction(settings.auction).treasury());\n }\n\n /// @notice Called upon initialization to add founders and compute their vesting allocations\n /// @dev We do this by reserving an mapping of [0-100] token indices, such that if a new token mint ID % 100 is reserved, it's sent to the appropriate founder.\n /// @param _founders The list of DAO founders\n function _addFounders(IManager.FounderParams[] calldata _founders) internal {\n // Cache the number of founders\n uint256 numFounders = _founders.length;\n\n // Used to store the total percent ownership among the founders\n uint256 totalOwnership;\n\n unchecked {\n // For each founder:\n for (uint256 i; i < numFounders; ++i) {\n // Cache the percent ownership\n uint256 founderPct = _founders[i].ownershipPct;\n\n // Continue if no ownership is specified\n if (founderPct == 0) {\n continue;\n }\n\n // Update the total ownership and ensure it's valid\n totalOwnership += founderPct;\n\n // Check that founders own less than 100% of tokens\n if (totalOwnership > 99) {\n revert INVALID_FOUNDER_OWNERSHIP();\n }\n\n // Compute the founder's id\n uint256 founderId = settings.numFounders++;\n\n // Get the pointer to store the founder\n Founder storage newFounder = founder[founderId];\n\n // Store the founder's vesting details\n newFounder.wallet = _founders[i].wallet;\n newFounder.vestExpiry = uint32(_founders[i].vestExpiry);\n // Total ownership cannot be above 100 so this fits safely in uint8\n newFounder.ownershipPct = uint8(founderPct);\n\n // Compute the vesting schedule\n uint256 schedule = 100 / founderPct;\n\n // Used to store the base token id the founder will recieve\n uint256 baseTokenId;\n\n // For each token to vest:\n for (uint256 j; j < founderPct; ++j) {\n // Get the available token id\n baseTokenId = _getNextTokenId(baseTokenId);\n\n // Store the founder as the recipient\n tokenRecipient[baseTokenId] = newFounder;\n\n emit MintScheduled(baseTokenId, founderId, newFounder);\n\n // Update the base token id\n baseTokenId = (baseTokenId + schedule) % 100;\n }\n }\n\n // Store the founders' details\n settings.totalOwnership = uint8(totalOwnership);\n settings.numFounders = uint8(numFounders);\n }\n }\n\n /// @dev Finds the next available base token id for a founder\n /// @param _tokenId The ERC-721 token id\n function _getNextTokenId(uint256 _tokenId) internal view returns (uint256) {\n unchecked {\n while (tokenRecipient[_tokenId].wallet != address(0)) {\n _tokenId = (++_tokenId) % 100;\n }\n\n return _tokenId;\n }\n }\n\n /// ///\n /// MINT ///\n /// ///\n\n /// @notice Mints tokens to the auction house for bidding and handles founder vesting\n function mint() external nonReentrant returns (uint256 tokenId) {\n // Cache the auction address\n address minter = settings.auction;\n\n // Ensure the caller is the auction\n if (msg.sender != minter) {\n revert ONLY_AUCTION();\n }\n\n // Cannot realistically overflow\n unchecked {\n do {\n // Get the next token to mint\n tokenId = settings.mintCount++;\n\n // Lookup whether the token is for a founder, and mint accordingly if so\n } while (_isForFounder(tokenId));\n }\n\n // Mint the next available token to the auction house for bidding\n _mint(minter, tokenId);\n }\n\n /// @dev Overrides _mint to include attribute generation\n /// @param _to The token recipient\n /// @param _tokenId The ERC-721 token id\n function _mint(address _to, uint256 _tokenId) internal override {\n // Mint the token\n super._mint(_to, _tokenId);\n\n // Increment the total supply\n unchecked {\n ++settings.totalSupply;\n }\n\n // Generate the token attributes\n if (!settings.metadataRenderer.onMinted(_tokenId)) revert NO_METADATA_GENERATED();\n }\n\n /// @dev Checks if a given token is for a founder and mints accordingly\n /// @param _tokenId The ERC-721 token id\n function _isForFounder(uint256 _tokenId) private returns (bool) {\n // Get the base token id\n uint256 baseTokenId = _tokenId % 100;\n\n // If there is no scheduled recipient:\n if (tokenRecipient[baseTokenId].wallet == address(0)) {\n return false;\n\n // Else if the founder is still vesting:\n } else if (block.timestamp < tokenRecipient[baseTokenId].vestExpiry) {\n // Mint the token to the founder\n _mint(tokenRecipient[baseTokenId].wallet, _tokenId);\n\n return true;\n\n // Else the founder has finished vesting:\n } else {\n // Remove them from future lookups\n delete tokenRecipient[baseTokenId];\n\n return false;\n }\n }\n\n /// ///\n /// BURN ///\n /// ///\n\n /// @notice Burns a token that did not see any bids\n /// @param _tokenId The ERC-721 token id\n function burn(uint256 _tokenId) external {\n // Ensure the caller is the auction house\n if (msg.sender != settings.auction) {\n revert ONLY_AUCTION();\n }\n\n // Burn the token\n _burn(_tokenId);\n }\n\n function _burn(uint256 _tokenId) internal override {\n super._burn(_tokenId);\n\n unchecked {\n --settings.totalSupply;\n }\n }\n\n /// ///\n /// METADATA ///\n /// ///\n\n /// @notice The URI for a token\n /// @param _tokenId The ERC-721 token id\n function tokenURI(uint256 _tokenId) public view override(IToken, ERC721) returns (string memory) {\n return settings.metadataRenderer.tokenURI(_tokenId);\n }\n\n /// @notice The URI for the contract\n function contractURI() public view override(IToken, ERC721) returns (string memory) {\n return settings.metadataRenderer.contractURI();\n }\n\n /// ///\n /// FOUNDERS ///\n /// ///\n\n /// @notice The number of founders\n function totalFounders() external view returns (uint256) {\n return settings.numFounders;\n }\n\n /// @notice The founders total percent ownership\n function totalFounderOwnership() external view returns (uint256) {\n return settings.totalOwnership;\n }\n\n /// @notice The vesting details of a founder\n /// @param _founderId The founder id\n function getFounder(uint256 _founderId) external view returns (Founder memory) {\n return founder[_founderId];\n }\n\n /// @notice The vesting details of all founders\n function getFounders() external view returns (Founder[] memory) {\n // Cache the number of founders\n uint256 numFounders = settings.numFounders;\n\n // Get a temporary array to hold all founders\n Founder[] memory founders = new Founder[](numFounders);\n\n // Cannot realistically overflow\n unchecked {\n // Add each founder to the array\n for (uint256 i; i < numFounders; ++i) {\n founders[i] = founder[i];\n }\n }\n\n return founders;\n }\n\n /// @notice The founder scheduled to receive the given token id\n /// NOTE: If a founder is returned, there's no guarantee they'll receive the token as vesting expiration is not considered\n /// @param _tokenId The ERC-721 token id\n function getScheduledRecipient(uint256 _tokenId) external view returns (Founder memory) {\n return tokenRecipient[_tokenId % 100];\n }\n\n /// ///\n /// SETTINGS ///\n /// ///\n\n /// @notice The total supply of tokens\n function totalSupply() external view returns (uint256) {\n return settings.totalSupply;\n }\n\n /// @notice The address of the auction house\n function auction() external view returns (address) {\n return settings.auction;\n }\n\n /// @notice The address of the metadata renderer\n function metadataRenderer() external view returns (address) {\n return address(settings.metadataRenderer);\n }\n\n function owner() public view override(IToken, Ownable) returns (address) {\n return super.owner();\n }\n\n /// ///\n /// TOKEN UPGRADE ///\n /// ///\n\n /// @notice Ensures the caller is authorized to upgrade the contract and that the new implementation is valid\n /// @dev This function is called in `upgradeTo` & `upgradeToAndCall`\n /// @param _newImpl The new implementation address\n function _authorizeUpgrade(address _newImpl) internal view override {\n // Ensure the caller is the shared owner of the token and metadata renderer\n if (msg.sender != owner()) revert ONLY_OWNER();\n\n // Ensure the implementation is valid\n if (!manager.isRegisteredUpgrade(_getImplementation(), _newImpl)) revert INVALID_UPGRADE(_newImpl);\n }\n}\n"
},
"src/governance/treasury/Treasury.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport { UUPS } from \"../../lib/proxy/UUPS.sol\";\nimport { Ownable } from \"../../lib/utils/Ownable.sol\";\nimport { ERC721TokenReceiver, ERC1155TokenReceiver } from \"../../lib/utils/TokenReceiver.sol\";\nimport { SafeCast } from \"../../lib/utils/SafeCast.sol\";\n\nimport { TreasuryStorageV1 } from \"./storage/TreasuryStorageV1.sol\";\nimport { ITreasury } from \"./ITreasury.sol\";\nimport { ProposalHasher } from \"../governor/ProposalHasher.sol\";\nimport { IManager } from \"../../manager/IManager.sol\";\n\n/// @title Treasury\n/// @author Rohan Kulkarni\n/// @notice A DAO's treasury and transaction executor\n/// Modified from:\n/// - OpenZeppelin Contracts v4.7.3 (governance/TimelockController.sol)\n/// - NounsDAOExecutor.sol commit 2cbe6c7 - licensed under the BSD-3-Clause license.\ncontract Treasury is ITreasury, UUPS, Ownable, ProposalHasher, TreasuryStorageV1 {\n /// ///\n /// CONSTANTS ///\n /// ///\n\n /// @notice The default grace period setting\n uint128 private constant INITIAL_GRACE_PERIOD = 2 weeks;\n\n /// ///\n /// IMMUTABLES ///\n /// ///\n\n /// @notice The contract upgrade manager\n IManager private immutable manager;\n\n /// ///\n /// CONSTRUCTOR ///\n /// ///\n\n /// @param _manager The contract upgrade manager address\n constructor(address _manager) payable initializer {\n manager = IManager(_manager);\n }\n\n /// ///\n /// INITIALIZER ///\n /// ///\n\n /// @notice Initializes an instance of a DAO's treasury\n /// @param _governor The DAO's governor address\n /// @param _delay The time delay to execute a queued transaction\n function initialize(address _governor, uint256 _delay) external initializer {\n // Ensure the caller is the contract manager\n if (msg.sender != address(manager)) revert ONLY_MANAGER();\n\n // Ensure a governor address was provided\n if (_governor == address(0)) revert ADDRESS_ZERO();\n\n // Grant ownership to the governor\n __Ownable_init(_governor);\n\n // Store the time delay\n settings.delay = SafeCast.toUint128(_delay);\n\n // Set the default grace period\n settings.gracePeriod = INITIAL_GRACE_PERIOD;\n\n emit DelayUpdated(0, _delay);\n }\n\n /// ///\n /// TRANSACTION STATE ///\n /// ///\n\n /// @notice The timestamp that a proposal is valid to execute\n /// @param _proposalId The proposal id\n function timestamp(bytes32 _proposalId) external view returns (uint256) {\n return timestamps[_proposalId];\n }\n\n /// @notice If a queued proposal can no longer be executed\n /// @param _proposalId The proposal id\n function isExpired(bytes32 _proposalId) external view returns (bool) {\n unchecked {\n return block.timestamp > (timestamps[_proposalId] + settings.gracePeriod);\n }\n }\n\n /// @notice If a proposal is queued\n /// @param _proposalId The proposal id\n function isQueued(bytes32 _proposalId) public view returns (bool) {\n return timestamps[_proposalId] != 0;\n }\n\n /// @notice If a proposal is ready to execute (does not consider expiration)\n /// @param _proposalId The proposal id\n function isReady(bytes32 _proposalId) public view returns (bool) {\n return timestamps[_proposalId] != 0 && block.timestamp >= timestamps[_proposalId];\n }\n\n /// ///\n /// QUEUE PROPOSAL ///\n /// ///\n\n /// @notice Schedules a proposal for execution\n /// @param _proposalId The proposal id\n function queue(bytes32 _proposalId) external onlyOwner returns (uint256 eta) {\n // Ensure the proposal was not already queued\n if (isQueued(_proposalId)) revert PROPOSAL_ALREADY_QUEUED();\n\n // Cannot realistically overflow\n unchecked {\n // Compute the timestamp that the proposal will be valid to execute\n eta = block.timestamp + settings.delay;\n }\n\n // Store the timestamp\n timestamps[_proposalId] = eta;\n\n emit TransactionScheduled(_proposalId, eta);\n }\n\n /// ///\n /// EXECUTE PROPOSAL ///\n /// ///\n\n /// @notice Executes a queued proposal\n /// @param _targets The target addresses to call\n /// @param _values The ETH values of each call\n /// @param _calldatas The calldata of each call\n /// @param _descriptionHash The hash of the description\n /// @param _proposer The proposal creator\n function execute(\n address[] calldata _targets,\n uint256[] calldata _values,\n bytes[] calldata _calldatas,\n bytes32 _descriptionHash,\n address _proposer\n ) external payable onlyOwner {\n // Get the proposal id\n bytes32 proposalId = hashProposal(_targets, _values, _calldatas, _descriptionHash, _proposer);\n\n // Ensure the proposal is ready to execute\n if (!isReady(proposalId)) revert EXECUTION_NOT_READY(proposalId);\n\n // Remove the proposal from the queue\n delete timestamps[proposalId];\n\n // Cache the number of targets\n uint256 numTargets = _targets.length;\n\n // Cannot realistically overflow\n unchecked {\n // For each target:\n for (uint256 i = 0; i < numTargets; ++i) {\n // Execute the transaction\n (bool success, ) = _targets[i].call{ value: _values[i] }(_calldatas[i]);\n\n // Ensure the transaction succeeded\n if (!success) revert EXECUTION_FAILED(i);\n }\n }\n\n emit TransactionExecuted(proposalId, _targets, _values, _calldatas);\n }\n\n /// ///\n /// CANCEL PROPOSAL ///\n /// ///\n\n /// @notice Removes a queued proposal\n /// @param _proposalId The proposal id\n function cancel(bytes32 _proposalId) external onlyOwner {\n // Ensure the proposal is queued\n if (!isQueued(_proposalId)) revert PROPOSAL_NOT_QUEUED();\n\n // Remove the proposal from the queue\n delete timestamps[_proposalId];\n\n emit TransactionCanceled(_proposalId);\n }\n\n /// ///\n /// TREASURY SETTINGS ///\n /// ///\n\n /// @notice The time delay to execute a queued transaction\n function delay() external view returns (uint256) {\n return settings.delay;\n }\n\n /// @notice The time period to execute a proposal\n function gracePeriod() external view returns (uint256) {\n return settings.gracePeriod;\n }\n\n /// ///\n /// UPDATE SETTINGS ///\n /// ///\n\n /// @notice Updates the transaction delay\n /// @param _newDelay The new time delay\n function updateDelay(uint256 _newDelay) external {\n // Ensure the caller is the treasury itself\n if (msg.sender != address(this)) revert ONLY_TREASURY();\n\n emit DelayUpdated(settings.delay, _newDelay);\n\n // Update the delay\n settings.delay = SafeCast.toUint128(_newDelay);\n }\n\n /// @notice Updates the execution grace period\n /// @param _newGracePeriod The new grace period\n function updateGracePeriod(uint256 _newGracePeriod) external {\n // Ensure the caller is the treasury itself\n if (msg.sender != address(this)) revert ONLY_TREASURY();\n\n emit GracePeriodUpdated(settings.gracePeriod, _newGracePeriod);\n\n // Update the grace period\n settings.gracePeriod = SafeCast.toUint128(_newGracePeriod);\n }\n\n /// ///\n /// RECEIVE TOKENS ///\n /// ///\n\n /// @dev Accepts all ERC-721 transfers\n function onERC721Received(\n address,\n address,\n uint256,\n bytes memory\n ) public pure returns (bytes4) {\n return ERC721TokenReceiver.onERC721Received.selector;\n }\n\n /// @dev Accepts all ERC-1155 single id transfers\n function onERC1155Received(\n address,\n address,\n uint256,\n uint256,\n bytes memory\n ) public pure returns (bytes4) {\n return ERC1155TokenReceiver.onERC1155Received.selector;\n }\n\n /// @dev Accept all ERC-1155 batch id transfers\n function onERC1155BatchReceived(\n address,\n address,\n uint256[] memory,\n uint256[] memory,\n bytes memory\n ) public pure returns (bytes4) {\n return ERC1155TokenReceiver.onERC1155BatchReceived.selector;\n }\n\n /// @dev Accepts ETH transfers\n receive() external payable {}\n\n /// ///\n /// TREASURY UPGRADE ///\n /// ///\n\n /// @notice Ensures the caller is authorized to upgrade the contract and that the new implementation is valid\n /// @dev This function is called in `upgradeTo` & `upgradeToAndCall`\n /// @param _newImpl The new implementation address\n function _authorizeUpgrade(address _newImpl) internal view override {\n // Ensure the caller is the treasury itself\n if (msg.sender != address(this)) revert ONLY_TREASURY();\n\n // Ensure the new implementation is a registered upgrade\n if (!manager.isRegisteredUpgrade(_getImplementation(), _newImpl)) revert INVALID_UPGRADE(_newImpl);\n }\n}\n"
},
"src/lib/utils/ReentrancyGuard.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport { Initializable } from \"../utils/Initializable.sol\";\n\n/// @notice Modified from OpenZeppelin Contracts v4.7.3 (security/ReentrancyGuardUpgradeable.sol)\n/// - Uses custom error `REENTRANCY()`\nabstract contract ReentrancyGuard is Initializable {\n /// ///\n /// STORAGE ///\n /// ///\n\n /// @dev Indicates a function has not been entered\n uint256 internal constant _NOT_ENTERED = 1;\n\n /// @dev Indicates a function has been entered\n uint256 internal constant _ENTERED = 2;\n\n /// @notice The reentrancy status of a function\n uint256 internal _status;\n\n /// ///\n /// ERRORS ///\n /// ///\n\n /// @dev Reverts if attempted reentrancy\n error REENTRANCY();\n\n /// ///\n /// FUNCTIONS ///\n /// ///\n\n /// @dev Initializes the reentrancy guard\n function __ReentrancyGuard_init() internal onlyInitializing {\n _status = _NOT_ENTERED;\n }\n\n /// @dev Ensures a function cannot be reentered\n modifier nonReentrant() {\n if (_status == _ENTERED) revert REENTRANCY();\n\n _status = _ENTERED;\n\n _;\n\n _status = _NOT_ENTERED;\n }\n}\n"
},
"src/lib/token/ERC721Votes.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport { IERC721Votes } from \"../interfaces/IERC721Votes.sol\";\nimport { ERC721 } from \"../token/ERC721.sol\";\nimport { EIP712 } from \"../utils/EIP712.sol\";\n\n/// @title ERC721Votes\n/// @author Rohan Kulkarni\n/// @notice Modified from OpenZeppelin Contracts v4.7.3 (token/ERC721/extensions/draft-ERC721Votes.sol) & Nouns DAO ERC721Checkpointable.sol commit 2cbe6c7 - licensed under the BSD-3-Clause license.\n/// - Uses custom errors defined in IERC721Votes\n/// - Checkpoints are based on timestamps instead of block numbers\n/// - Tokens are self-delegated by default\n/// - The total number of votes is the token supply itself\nabstract contract ERC721Votes is IERC721Votes, EIP712, ERC721 {\n /// ///\n /// CONSTANTS ///\n /// ///\n\n /// @dev The EIP-712 typehash to delegate with a signature\n bytes32 internal constant DELEGATION_TYPEHASH = keccak256(\"Delegation(address from,address to,uint256 nonce,uint256 deadline)\");\n\n /// ///\n /// STORAGE ///\n /// ///\n\n /// @notice The delegate for an account\n /// @notice Account => Delegate\n mapping(address => address) internal delegation;\n\n /// @notice The number of checkpoints for an account\n /// @dev Account => Num Checkpoints\n mapping(address => uint256) internal numCheckpoints;\n\n /// @notice The checkpoint for an account\n /// @dev Account => Checkpoint Id => Checkpoint\n mapping(address => mapping(uint256 => Checkpoint)) internal checkpoints;\n\n /// ///\n /// VOTING WEIGHT ///\n /// ///\n\n /// @notice The current number of votes for an account\n /// @param _account The account address\n function getVotes(address _account) public view returns (uint256) {\n // Get the account's number of checkpoints\n uint256 nCheckpoints = numCheckpoints[_account];\n\n // Cannot underflow as `nCheckpoints` is ensured to be greater than 0 if reached\n unchecked {\n // Return the number of votes at the latest checkpoint if applicable\n return nCheckpoints != 0 ? checkpoints[_account][nCheckpoints - 1].votes : 0;\n }\n }\n\n /// @notice The number of votes for an account at a past timestamp\n /// @param _account The account address\n /// @param _timestamp The past timestamp\n function getPastVotes(address _account, uint256 _timestamp) public view returns (uint256) {\n // Ensure the given timestamp is in the past\n if (_timestamp >= block.timestamp) revert INVALID_TIMESTAMP();\n\n // Get the account's number of checkpoints\n uint256 nCheckpoints = numCheckpoints[_account];\n\n // If there are none return 0\n if (nCheckpoints == 0) return 0;\n\n // Get the account's checkpoints\n mapping(uint256 => Checkpoint) storage accountCheckpoints = checkpoints[_account];\n\n unchecked {\n // Get the latest checkpoint id\n // Cannot underflow as `nCheckpoints` is ensured to be greater than 0\n uint256 lastCheckpoint = nCheckpoints - 1;\n\n // If the latest checkpoint has a valid timestamp, return its number of votes\n if (accountCheckpoints[lastCheckpoint].timestamp <= _timestamp) return accountCheckpoints[lastCheckpoint].votes;\n\n // If the first checkpoint doesn't have a valid timestamp, return 0\n if (accountCheckpoints[0].timestamp > _timestamp) return 0;\n\n // Otherwise, find a checkpoint with a valid timestamp\n // Use the latest id as the initial upper bound\n uint256 high = lastCheckpoint;\n uint256 low;\n uint256 middle;\n\n // Used to temporarily hold a checkpoint\n Checkpoint memory cp;\n\n // While a valid checkpoint is to be found:\n while (high > low) {\n // Find the id of the middle checkpoint\n middle = high - (high - low) / 2;\n\n // Get the middle checkpoint\n cp = accountCheckpoints[middle];\n\n // If the timestamp is a match:\n if (cp.timestamp == _timestamp) {\n // Return the voting weight\n return cp.votes;\n\n // Else if the timestamp is before the one looking for:\n } else if (cp.timestamp < _timestamp) {\n // Update the lower bound\n low = middle;\n\n // Else update the upper bound\n } else {\n high = middle - 1;\n }\n }\n\n return accountCheckpoints[low].votes;\n }\n }\n\n /// ///\n /// DELEGATION ///\n /// ///\n\n /// @notice The delegate for an account\n /// @param _account The account address\n function delegates(address _account) public view returns (address) {\n address current = delegation[_account];\n return current == address(0) ? _account : current;\n }\n\n /// @notice Delegates votes to an account\n /// @param _to The address delegating votes to\n function delegate(address _to) external {\n _delegate(msg.sender, _to);\n }\n\n /// @notice Delegates votes from a signer to an account\n /// @param _from The address delegating votes from\n /// @param _to The address delegating votes to\n /// @param _deadline The signature deadline\n /// @param _v The 129th byte and chain id of the signature\n /// @param _r The first 64 bytes of the signature\n /// @param _s Bytes 64-128 of the signature\n function delegateBySig(\n address _from,\n address _to,\n uint256 _deadline,\n uint8 _v,\n bytes32 _r,\n bytes32 _s\n ) external {\n // Ensure the signature has not expired\n if (block.timestamp > _deadline) revert EXPIRED_SIGNATURE();\n\n // Used to store the digest\n bytes32 digest;\n\n // Cannot realistically overflow\n unchecked {\n // Compute the hash of the domain seperator with the typed delegation data\n digest = keccak256(\n abi.encodePacked(\"\\x19\\x01\", DOMAIN_SEPARATOR(), keccak256(abi.encode(DELEGATION_TYPEHASH, _from, _to, nonces[_from]++, _deadline)))\n );\n }\n\n // Recover the message signer\n address recoveredAddress = ecrecover(digest, _v, _r, _s);\n\n // Ensure the recovered signer is the voter\n if (recoveredAddress == address(0) || recoveredAddress != _from) revert INVALID_SIGNATURE();\n\n // Update the delegate\n _delegate(_from, _to);\n }\n\n /// @dev Updates delegate addresses\n /// @param _from The address delegating votes from\n /// @param _to The address delegating votes to\n function _delegate(address _from, address _to) internal {\n // If address(0) is being delegated to, update the op as a self-delegate\n if (_to == address(0)) _to = _from;\n\n // Get the previous delegate\n address prevDelegate = delegates(_from);\n\n // Store the new delegate\n delegation[_from] = _to;\n\n emit DelegateChanged(_from, prevDelegate, _to);\n\n // Transfer voting weight from the previous delegate to the new delegate\n _moveDelegateVotes(prevDelegate, _to, balanceOf(_from));\n }\n\n /// @dev Transfers voting weight\n /// @param _from The address delegating votes from\n /// @param _to The address delegating votes to\n /// @param _amount The number of votes delegating\n function _moveDelegateVotes(\n address _from,\n address _to,\n uint256 _amount\n ) internal {\n unchecked {\n // If voting weight is being transferred:\n if (_from != _to && _amount > 0) {\n // If this isn't a token mint:\n if (_from != address(0)) {\n // Get the sender's number of checkpoints\n uint256 newCheckpointId = numCheckpoints[_from];\n\n // Used to store their previous checkpoint id\n uint256 prevCheckpointId;\n\n // Used to store their previous checkpoint's voting weight\n uint256 prevTotalVotes;\n\n // Used to store their previous checkpoint's timestamp\n uint256 prevTimestamp;\n\n // If this isn't the sender's first checkpoint:\n if (newCheckpointId != 0) {\n // Get their previous checkpoint's id\n prevCheckpointId = newCheckpointId - 1;\n\n // Get their previous checkpoint's voting weight\n prevTotalVotes = checkpoints[_from][prevCheckpointId].votes;\n\n // Get their previous checkpoint's timestamp\n prevTimestamp = checkpoints[_from][prevCheckpointId].timestamp;\n }\n\n // Update their voting weight\n _writeCheckpoint(_from, newCheckpointId, prevCheckpointId, prevTimestamp, prevTotalVotes, prevTotalVotes - _amount);\n }\n\n // If this isn't a token burn:\n if (_to != address(0)) {\n // Get the recipients's number of checkpoints\n uint256 nCheckpoints = numCheckpoints[_to];\n\n // Used to store their previous checkpoint id\n uint256 prevCheckpointId;\n\n // Used to store their previous checkpoint's voting weight\n uint256 prevTotalVotes;\n\n // Used to store their previous checkpoint's timestamp\n uint256 prevTimestamp;\n\n // If this isn't the recipient's first checkpoint:\n if (nCheckpoints != 0) {\n // Get their previous checkpoint's id\n prevCheckpointId = nCheckpoints - 1;\n\n // Get their previous checkpoint's voting weight\n prevTotalVotes = checkpoints[_to][prevCheckpointId].votes;\n\n // Get their previous checkpoint's timestamp\n prevTimestamp = checkpoints[_to][prevCheckpointId].timestamp;\n }\n\n // Update their voting weight\n _writeCheckpoint(_to, nCheckpoints, prevCheckpointId, prevTimestamp, prevTotalVotes, prevTotalVotes + _amount);\n }\n }\n }\n }\n\n /// @dev Records a checkpoint\n /// @param _account The account address\n /// @param _newId The new checkpoint id\n /// @param _prevId The previous checkpoint id\n /// @param _prevTimestamp The previous checkpoint timestamp\n /// @param _prevTotalVotes The previous checkpoint voting weight\n /// @param _newTotalVotes The new checkpoint voting weight\n function _writeCheckpoint(\n address _account,\n uint256 _newId,\n uint256 _prevId,\n uint256 _prevTimestamp,\n uint256 _prevTotalVotes,\n uint256 _newTotalVotes\n ) private {\n unchecked {\n // If the new checkpoint is not the user's first AND has the timestamp of the previous checkpoint:\n if (_newId > 0 && _prevTimestamp == block.timestamp) {\n // Just update the previous checkpoint's votes\n checkpoints[_account][_prevId].votes = uint192(_newTotalVotes);\n\n // Else write a new checkpoint:\n } else {\n // Get the pointer to store the checkpoint\n Checkpoint storage checkpoint = checkpoints[_account][_newId];\n\n // Store the new voting weight and the current time\n checkpoint.votes = uint192(_newTotalVotes);\n checkpoint.timestamp = uint64(block.timestamp);\n\n // Increment the account's number of checkpoints\n ++numCheckpoints[_account];\n }\n\n emit DelegateVotesChanged(_account, _prevTotalVotes, _newTotalVotes);\n }\n }\n\n /// @dev Enables each NFT to equal 1 vote\n /// @param _from The token sender\n /// @param _to The token recipient\n /// @param _tokenId The ERC-721 token id\n function _afterTokenTransfer(\n address _from,\n address _to,\n uint256 _tokenId\n ) internal override {\n // Transfer 1 vote from the sender to the recipient\n _moveDelegateVotes(delegates(_from), delegates(_to), 1);\n\n super._afterTokenTransfer(_from, _to, _tokenId);\n }\n}\n"
},
"src/lib/token/ERC721.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport { IERC721 } from \"../interfaces/IERC721.sol\";\nimport { Initializable } from \"../utils/Initializable.sol\";\nimport { ERC721TokenReceiver } from \"../utils/TokenReceiver.sol\";\nimport { Address } from \"../utils/Address.sol\";\n\n/// @title ERC721\n/// @author Rohan Kulkarni\n/// @notice Modified from OpenZeppelin Contracts v4.7.3 (token/ERC721/ERC721Upgradeable.sol)\n/// - Uses custom errors declared in IERC721\nabstract contract ERC721 is IERC721, Initializable {\n /// ///\n /// STORAGE ///\n /// ///\n\n /// @notice The token name\n string public name;\n\n /// @notice The token symbol\n string public symbol;\n\n /// @notice The token owners\n /// @dev ERC-721 token id => Owner\n mapping(uint256 => address) internal owners;\n\n /// @notice The owner balances\n /// @dev Owner => Balance\n mapping(address => uint256) internal balances;\n\n /// @notice The token approvals\n /// @dev ERC-721 token id => Manager\n mapping(uint256 => address) internal tokenApprovals;\n\n /// @notice The balance approvals\n /// @dev Owner => Operator => Approved\n mapping(address => mapping(address => bool)) internal operatorApprovals;\n\n /// ///\n /// FUNCTIONS ///\n /// ///\n\n /// @dev Initializes an ERC-721 token\n /// @param _name The ERC-721 token name\n /// @param _symbol The ERC-721 token symbol\n function __ERC721_init(string memory _name, string memory _symbol) internal onlyInitializing {\n name = _name;\n symbol = _symbol;\n }\n\n /// @notice The token URI\n /// @param _tokenId The ERC-721 token id\n function tokenURI(uint256 _tokenId) public view virtual returns (string memory) {}\n\n /// @notice The contract URI\n function contractURI() public view virtual returns (string memory) {}\n\n /// @notice If the contract implements an interface\n /// @param _interfaceId The interface id\n function supportsInterface(bytes4 _interfaceId) external pure returns (bool) {\n return\n _interfaceId == 0x01ffc9a7 || // ERC165 Interface ID\n _interfaceId == 0x80ac58cd || // ERC721 Interface ID\n _interfaceId == 0x5b5e139f; // ERC721Metadata Interface ID\n }\n\n /// @notice The account approved to manage a token\n /// @param _tokenId The ERC-721 token id\n function getApproved(uint256 _tokenId) external view returns (address) {\n return tokenApprovals[_tokenId];\n }\n\n /// @notice If an operator is authorized to manage all of an owner's tokens\n /// @param _owner The owner address\n /// @param _operator The operator address\n function isApprovedForAll(address _owner, address _operator) external view returns (bool) {\n return operatorApprovals[_owner][_operator];\n }\n\n /// @notice The number of tokens owned\n /// @param _owner The owner address\n function balanceOf(address _owner) public view returns (uint256) {\n if (_owner == address(0)) revert ADDRESS_ZERO();\n\n return balances[_owner];\n }\n\n /// @notice The owner of a token\n /// @param _tokenId The ERC-721 token id\n function ownerOf(uint256 _tokenId) public view returns (address) {\n address owner = owners[_tokenId];\n\n if (owner == address(0)) revert INVALID_OWNER();\n\n return owner;\n }\n\n /// @notice Authorizes an account to manage a token\n /// @param _to The account address\n /// @param _tokenId The ERC-721 token id\n function approve(address _to, uint256 _tokenId) external {\n address owner = owners[_tokenId];\n\n if (msg.sender != owner && !operatorApprovals[owner][msg.sender]) revert INVALID_APPROVAL();\n\n tokenApprovals[_tokenId] = _to;\n\n emit Approval(owner, _to, _tokenId);\n }\n\n /// @notice Authorizes an account to manage all tokens\n /// @param _operator The account address\n /// @param _approved If permission is being given or removed\n function setApprovalForAll(address _operator, bool _approved) external {\n operatorApprovals[msg.sender][_operator] = _approved;\n\n emit ApprovalForAll(msg.sender, _operator, _approved);\n }\n\n /// @notice Transfers a token from sender to recipient\n /// @param _from The sender address\n /// @param _to The recipient address\n /// @param _tokenId The ERC-721 token id\n function transferFrom(\n address _from,\n address _to,\n uint256 _tokenId\n ) public {\n if (_from != owners[_tokenId]) revert INVALID_OWNER();\n\n if (_to == address(0)) revert ADDRESS_ZERO();\n\n if (msg.sender != _from && !operatorApprovals[_from][msg.sender] && msg.sender != tokenApprovals[_tokenId]) revert INVALID_APPROVAL();\n\n _beforeTokenTransfer(_from, _to, _tokenId);\n\n unchecked {\n --balances[_from];\n\n ++balances[_to];\n }\n\n owners[_tokenId] = _to;\n\n delete tokenApprovals[_tokenId];\n\n emit Transfer(_from, _to, _tokenId);\n\n _afterTokenTransfer(_from, _to, _tokenId);\n }\n\n /// @notice Safe transfers a token from sender to recipient\n /// @param _from The sender address\n /// @param _to The recipient address\n /// @param _tokenId The ERC-721 token id\n function safeTransferFrom(\n address _from,\n address _to,\n uint256 _tokenId\n ) external {\n transferFrom(_from, _to, _tokenId);\n\n if (\n Address.isContract(_to) &&\n ERC721TokenReceiver(_to).onERC721Received(msg.sender, _from, _tokenId, \"\") != ERC721TokenReceiver.onERC721Received.selector\n ) revert INVALID_RECIPIENT();\n }\n\n /// @notice Safe transfers a token from sender to recipient with additional data\n /// @param _from The sender address\n /// @param _to The recipient address\n /// @param _tokenId The ERC-721 token id\n function safeTransferFrom(\n address _from,\n address _to,\n uint256 _tokenId,\n bytes calldata _data\n ) external {\n transferFrom(_from, _to, _tokenId);\n\n if (\n Address.isContract(_to) &&\n ERC721TokenReceiver(_to).onERC721Received(msg.sender, _from, _tokenId, _data) != ERC721TokenReceiver.onERC721Received.selector\n ) revert INVALID_RECIPIENT();\n }\n\n /// @dev Mints a token to a recipient\n /// @param _to The recipient address\n /// @param _tokenId The ERC-721 token id\n function _mint(address _to, uint256 _tokenId) internal virtual {\n if (_to == address(0)) revert ADDRESS_ZERO();\n\n if (owners[_tokenId] != address(0)) revert ALREADY_MINTED();\n\n _beforeTokenTransfer(address(0), _to, _tokenId);\n\n unchecked {\n ++balances[_to];\n }\n\n owners[_tokenId] = _to;\n\n emit Transfer(address(0), _to, _tokenId);\n\n _afterTokenTransfer(address(0), _to, _tokenId);\n }\n\n /// @dev Burns a token to a recipient\n /// @param _tokenId The ERC-721 token id\n function _burn(uint256 _tokenId) internal virtual {\n address owner = owners[_tokenId];\n\n if (owner == address(0)) revert NOT_MINTED();\n\n _beforeTokenTransfer(owner, address(0), _tokenId);\n\n unchecked {\n --balances[owner];\n }\n\n delete owners[_tokenId];\n\n delete tokenApprovals[_tokenId];\n\n emit Transfer(owner, address(0), _tokenId);\n\n _afterTokenTransfer(owner, address(0), _tokenId);\n }\n\n /// @dev Hook called before a token transfer\n /// @param _from The sender address\n /// @param _to The recipient address\n /// @param _tokenId The ERC-721 token id\n function _beforeTokenTransfer(\n address _from,\n address _to,\n uint256 _tokenId\n ) internal virtual {}\n\n /// @dev Hook called after a token transfer\n /// @param _from The sender address\n /// @param _to The recipient address\n /// @param _tokenId The ERC-721 token id\n function _afterTokenTransfer(\n address _from,\n address _to,\n uint256 _tokenId\n ) internal virtual {}\n}\n"
},
"src/token/storage/TokenStorageV1.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport { TokenTypesV1 } from \"../types/TokenTypesV1.sol\";\n\n/// @title TokenStorageV1\n/// @author Rohan Kulkarni\n/// @notice The Token storage contract\ncontract TokenStorageV1 is TokenTypesV1 {\n /// @notice The token settings\n Settings internal settings;\n\n /// @notice The vesting details of a founder\n /// @dev Founder id => Founder\n mapping(uint256 => Founder) internal founder;\n\n /// @notice The recipient of a token\n /// @dev ERC-721 token id => Founder\n mapping(uint256 => Founder) internal tokenRecipient;\n}\n"
},
"src/lib/utils/TokenReceiver.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @notice Modified from OpenZeppelin Contracts v4.7.3 (token/ERC721/utils/ERC721Holder.sol)\nabstract contract ERC721TokenReceiver {\n function onERC721Received(\n address,\n address,\n uint256,\n bytes calldata\n ) external virtual returns (bytes4) {\n return this.onERC721Received.selector;\n }\n}\n\n/// @notice Modified from OpenZeppelin Contracts v4.7.3 (token/ERC1155/utils/ERC1155Holder.sol)\nabstract contract ERC1155TokenReceiver {\n function onERC1155Received(\n address,\n address,\n uint256,\n uint256,\n bytes calldata\n ) external virtual returns (bytes4) {\n return this.onERC1155Received.selector;\n }\n\n function onERC1155BatchReceived(\n address,\n address,\n uint256[] calldata,\n uint256[] calldata,\n bytes calldata\n ) external virtual returns (bytes4) {\n return this.onERC1155BatchReceived.selector;\n }\n}\n"
},
"src/lib/utils/SafeCast.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\n/// @notice Modified from OpenZeppelin Contracts v4.7.3 (utils/math/SafeCast.sol)\n/// - Uses custom error `UNSAFE_CAST()`\nlibrary SafeCast {\n error UNSAFE_CAST();\n\n function toUint128(uint256 x) internal pure returns (uint128) {\n if (x > type(uint128).max) revert UNSAFE_CAST();\n\n return uint128(x);\n }\n\n function toUint64(uint256 x) internal pure returns (uint64) {\n if (x > type(uint64).max) revert UNSAFE_CAST();\n\n return uint64(x);\n }\n\n function toUint48(uint256 x) internal pure returns (uint48) {\n if (x > type(uint48).max) revert UNSAFE_CAST();\n\n return uint48(x);\n }\n\n function toUint40(uint256 x) internal pure returns (uint40) {\n if (x > type(uint40).max) revert UNSAFE_CAST();\n\n return uint40(x);\n }\n\n function toUint32(uint256 x) internal pure returns (uint32) {\n if (x > type(uint32).max) revert UNSAFE_CAST();\n\n return uint32(x);\n }\n\n function toUint16(uint256 x) internal pure returns (uint16) {\n if (x > type(uint16).max) revert UNSAFE_CAST();\n\n return uint16(x);\n }\n\n function toUint8(uint256 x) internal pure returns (uint8) {\n if (x > type(uint8).max) revert UNSAFE_CAST();\n\n return uint8(x);\n }\n}\n"
},
"src/governance/treasury/storage/TreasuryStorageV1.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\nimport { TreasuryTypesV1 } from \"../types/TreasuryTypesV1.sol\";\n\n/// @notice TreasuryStorageV1\n/// @author Rohan Kulkarni\n/// @notice The Treasury storage contract\ncontract TreasuryStorageV1 is TreasuryTypesV1 {\n /// @notice The treasury settings\n Settings internal settings;\n\n /// @notice The timestamp that a queued proposal is ready to execute\n /// @dev Proposal Id => Timestamp\n mapping(bytes32 => uint256) internal timestamps;\n}\n"
},
"src/governance/governor/ProposalHasher.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\n/// @title ProposalHasher\n/// @author tbtstl\n/// @notice Helper contract to ensure proposal hashing functions are unified\nabstract contract ProposalHasher {\n /// ///\n /// HASH PROPOSAL ///\n /// ///\n\n /// @notice Hashes a proposal's details into a proposal id\n /// @param _targets The target addresses to call\n /// @param _values The ETH values of each call\n /// @param _calldatas The calldata of each call\n /// @param _descriptionHash The hash of the description\n /// @param _proposer The original proposer of the transaction\n function hashProposal(\n address[] memory _targets,\n uint256[] memory _values,\n bytes[] memory _calldatas,\n bytes32 _descriptionHash,\n address _proposer\n ) public pure returns (bytes32) {\n return keccak256(abi.encode(_targets, _values, _calldatas, _descriptionHash, _proposer));\n }\n}\n"
},
"src/governance/treasury/types/TreasuryTypesV1.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.16;\n\n/// @notice TreasuryTypesV1\n/// @author Rohan Kulkarni\n/// @notice The treasury's custom data types\ncontract TreasuryTypesV1 {\n /// @notice The settings type\n /// @param gracePeriod The time period to execute a proposal\n /// @param delay The time delay to execute a queued transaction\n struct Settings {\n uint128 gracePeriod;\n uint128 delay;\n }\n}\n"
}
},
"settings": {
"remappings": [
"@openzeppelin/=node_modules/@openzeppelin/",
"ds-test/=lib/forge-std/lib/ds-test/src/",
"forge-std/=lib/forge-std/src/",
"micro-onchain-metadata-utils/=node_modules/micro-onchain-metadata-utils/src/",
"sol-uriencode/=node_modules/sol-uriencode/",
"sol2string/=node_modules/sol2string/"
],
"optimizer": {
"enabled": true,
"runs": 500000
},
"metadata": {
"bytecodeHash": "ipfs"
},
"outputSelection": {
"*": {
"*": [
"evm.bytecode",
"evm.deployedBytecode",
"devdoc",
"userdoc",
"metadata",
"abi"
]
}
},
"evmVersion": "london",
"libraries": {}
}
} |