Contract Name:
FactoryRegistry
Contract Source Code:
File 1 of 1 : FactoryRegistry
// SPDX-License-Identifier: GPL-3.0-or-later
// Hydrometer combines powerful liquidity incentives, low slippage, and a vote-locked governance model using $HYDRO and $veHYDRO tokens, ensuring an innovative and decentralized experience for all users.
//https://x.com/Hydrometer_Fi
pragma solidity 0.8.19;
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_transferOwnership(_msgSender());
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
_checkOwner();
_;
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IFactoryRegistry {
error FallbackFactory();
error InvalidFactoriesToPoolFactory();
error PathAlreadyApproved();
error PathNotApproved();
error SameAddress();
error ZeroAddress();
event Approve(address indexed poolFactory, address indexed votingRewardsFactory, address indexed gaugeFactory);
event Unapprove(address indexed poolFactory, address indexed votingRewardsFactory, address indexed gaugeFactory);
event SetManagedRewardsFactory(address indexed _newRewardsFactory);
/// @notice Approve a set of factories used in the Protocol.
/// Router.sol is able to swap any poolFactories currently approved.
/// Cannot approve address(0) factories.
/// Cannot aprove path that is already approved.
/// Each poolFactory has one unique set and maintains state. In the case a poolFactory is unapproved
/// and then re-approved, the same set of factories must be used. In other words, you cannot overwrite
/// the factories tied to a poolFactory address.
/// VotingRewardsFactories and GaugeFactories may use the same address across multiple poolFactories.
/// @dev Callable by onlyOwner
/// @param poolFactory .
/// @param votingRewardsFactory .
/// @param gaugeFactory .
function approve(address poolFactory, address votingRewardsFactory, address gaugeFactory) external;
/// @notice Unapprove a set of factories used in the Protocol.
/// While a poolFactory is unapproved, Router.sol cannot swap with pools made from the corresponding factory
/// Can only unapprove an approved path.
/// Cannot unapprove the fallback path (core v2 factories).
/// @dev Callable by onlyOwner
/// @param poolFactory .
function unapprove(address poolFactory) external;
/// @notice Factory to create free and locked rewards for a managed veNFT
function managedRewardsFactory() external view returns (address);
/// @notice Set the rewards factory address
/// @dev Callable by onlyOwner
/// @param _newManagedRewardsFactory address of new managedRewardsFactory
function setManagedRewardsFactory(address _newManagedRewardsFactory) external;
/// @notice Get the factories correlated to a poolFactory.
/// Once set, this can never be modified.
/// Returns the correlated factories even after an approved poolFactory is unapproved.
function factoriesToPoolFactory(
address poolFactory
) external view returns (address votingRewardsFactory, address gaugeFactory);
/// @notice Get all PoolFactories approved by the registry
/// @dev The same PoolFactory address cannot be used twice
/// @return Array of PoolFactory addresses
function poolFactories() external view returns (address[] memory);
/// @notice Check if a PoolFactory is approved within the factory registry. Router uses this method to
/// ensure a pool swapped from is approved.
/// @param poolFactory .
/// @return True if PoolFactory is approved, else false
function isPoolFactoryApproved(address poolFactory) external view returns (bool);
/// @notice Get the length of the poolFactories array
function poolFactoriesLength() external view returns (uint256);
}
// OpenZeppelin Contracts (last updated v4.8.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.
/**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```solidity
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
* and `uint256` (`UintSet`) are supported.
*
* [WARNING]
* ====
* Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
* unusable.
* See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
*
* In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
* array of EnumerableSet.
* ====
*/
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping(bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {
// Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
if (lastIndex != toDeleteIndex) {
bytes32 lastValue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastValue;
// Update the index for the moved value
set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
}
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
return set._values[index];
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function _values(Set storage set) private view returns (bytes32[] memory) {
return set._values;
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
bytes32[] memory store = _values(set._inner);
bytes32[] memory result;
/// @solidity memory-safe-assembly
assembly {
result := store
}
return result;
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(AddressSet storage set) internal view returns (address[] memory) {
bytes32[] memory store = _values(set._inner);
address[] memory result;
/// @solidity memory-safe-assembly
assembly {
result := store
}
return result;
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(UintSet storage set) internal view returns (uint256[] memory) {
bytes32[] memory store = _values(set._inner);
uint256[] memory result;
/// @solidity memory-safe-assembly
assembly {
result := store
}
return result;
}
}
/// @title Protocol Factory Registry
/// @author Carter Carlson (@pegahcarter)
/// @notice Protocol Factory Registry to swap and create gauges
contract FactoryRegistry is IFactoryRegistry, Ownable {
using EnumerableSet for EnumerableSet.AddressSet;
/// @dev factory to create free and locked rewards for a managed veNFT
address private _managedRewardsFactory;
/// @dev The protocol will always have a usable poolFactory, votingRewardsFactory, and gaugeFactory. The votingRewardsFactory
// and gaugeFactory are defined to the poolFactory which can never be removed
address public immutable fallbackPoolFactory;
/// @dev Array of poolFactories used to create a gauge and votingRewards
EnumerableSet.AddressSet private _poolFactories;
struct FactoriesToPoolFactory {
address votingRewardsFactory;
address gaugeFactory;
}
/// @dev the factories linked to the poolFactory
mapping(address => FactoriesToPoolFactory) private _factoriesToPoolsFactory;
constructor(
address _fallbackPoolFactory,
address _fallbackVotingRewardsFactory,
address _fallbackGaugeFactory,
address _newManagedRewardsFactory
) {
fallbackPoolFactory = _fallbackPoolFactory;
approve(_fallbackPoolFactory, _fallbackVotingRewardsFactory, _fallbackGaugeFactory);
setManagedRewardsFactory(_newManagedRewardsFactory);
}
/// @inheritdoc IFactoryRegistry
function approve(address poolFactory, address votingRewardsFactory, address gaugeFactory) public onlyOwner {
if (poolFactory == address(0) || votingRewardsFactory == address(0) || gaugeFactory == address(0))
revert ZeroAddress();
if (_poolFactories.contains(poolFactory)) revert PathAlreadyApproved();
FactoriesToPoolFactory memory usedFactories = _factoriesToPoolsFactory[poolFactory];
// If the poolFactory *has not* been approved before, can approve any gauge/votingRewards factory
// Only one check is sufficient
if (usedFactories.votingRewardsFactory == address(0)) {
_factoriesToPoolsFactory[poolFactory] = FactoriesToPoolFactory(votingRewardsFactory, gaugeFactory);
} else {
// If the poolFactory *has* been approved before, can only approve the same used gauge/votingRewards factory to
// to maintain state within Voter
if (
votingRewardsFactory != usedFactories.votingRewardsFactory || gaugeFactory != usedFactories.gaugeFactory
) revert InvalidFactoriesToPoolFactory();
}
_poolFactories.add(poolFactory);
emit Approve(poolFactory, votingRewardsFactory, gaugeFactory);
}
/// @inheritdoc IFactoryRegistry
function unapprove(address poolFactory) external onlyOwner {
if (poolFactory == fallbackPoolFactory) revert FallbackFactory();
if (!_poolFactories.contains(poolFactory)) revert PathNotApproved();
_poolFactories.remove(poolFactory);
(address votingRewardsFactory, address gaugeFactory) = factoriesToPoolFactory(poolFactory);
emit Unapprove(poolFactory, votingRewardsFactory, gaugeFactory);
}
/// @inheritdoc IFactoryRegistry
function setManagedRewardsFactory(address _newManagedRewardsFactory) public onlyOwner {
if (_newManagedRewardsFactory == _managedRewardsFactory) revert SameAddress();
if (_newManagedRewardsFactory == address(0)) revert ZeroAddress();
_managedRewardsFactory = _newManagedRewardsFactory;
emit SetManagedRewardsFactory(_newManagedRewardsFactory);
}
/// @inheritdoc IFactoryRegistry
function managedRewardsFactory() external view returns (address) {
return _managedRewardsFactory;
}
/// @inheritdoc IFactoryRegistry
function factoriesToPoolFactory(
address poolFactory
) public view returns (address votingRewardsFactory, address gaugeFactory) {
FactoriesToPoolFactory memory f = _factoriesToPoolsFactory[poolFactory];
votingRewardsFactory = f.votingRewardsFactory;
gaugeFactory = f.gaugeFactory;
}
/// @inheritdoc IFactoryRegistry
function poolFactories() external view returns (address[] memory) {
return _poolFactories.values();
}
/// @inheritdoc IFactoryRegistry
function isPoolFactoryApproved(address poolFactory) external view returns (bool) {
return _poolFactories.contains(poolFactory);
}
/// @inheritdoc IFactoryRegistry
function poolFactoriesLength() external view returns (uint256) {
return _poolFactories.length();
}
}