@oldzeppelin/contract 1.1.1

package/contracts/main/contracts/core/CoreWhitelist.sol

@@ -0,0 +1,192 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import {EnumerableSet} from '@openzeppelin/contracts/utils/structs/EnumerableSet.sol';
+import {NZGuard} from '../../shared/NZGuard.sol';
+import {UFarmErrors} from '../../shared/UFarmErrors.sol';
+import {ICoreWhitelist} from './ICoreWhitelist.sol';
+import {ERC20} from '@openzeppelin/contracts/token/ERC20/ERC20.sol';
+
+/**
+ * @title TokenWhitelist
+ * @author https://ufarm.digital/
+ * @notice Keeps track of all tokens that can be used in the system.
+ */
+abstract contract CoreWhitelist is ICoreWhitelist, NZGuard, UFarmErrors {
+	using EnumerableSet for EnumerableSet.AddressSet;
+	using EnumerableSet for EnumerableSet.Bytes32Set;
+
+	mapping(bytes32 => address) public controllers;
+	mapping(address => AssetWithPriceFeed) private _tokenInfo;
+
+	EnumerableSet.AddressSet private __tokens;
+	EnumerableSet.Bytes32Set private __protocols;
+
+	event TokenAdded(AssetWithPriceFeed assetInfo);
+	event TokenRemoved(address indexed token);
+	event ProtocolAdded(bytes32 indexed protocol, address indexed controller);
+	event ProtocolUpdated(bytes32 indexed protocol, address indexed controller);
+	event ProtocolRemoved(bytes32 indexed protocol, address indexed controller);
+
+	error DecimalsMismatch();
+	error TokenAlreadyAdded(address token);
+	error TokenNotRemoved(address token);
+	error ProtocolNotAllowed(bytes32 protocol);
+
+	/**
+	 * @inheritdoc ICoreWhitelist
+	 */
+	function tokenInfo(
+		address token
+	) external view override returns (AssetWithPriceFeed memory info) {
+		return _tokenInfo[token];
+	}
+
+	/**
+	 * @inheritdoc ICoreWhitelist
+	 */
+	function whitelistProtocolsWithControllers(
+		bytes32[] memory _protocolNames,
+		address[] memory _protocolControllers
+	) public virtual override {
+		uint256 controllersLength = _protocolControllers.length;
+
+		if (_protocolNames.length != controllersLength) revert ArraysLengthMismatch();
+		_nonEmptyArray(controllersLength);
+
+		for (uint256 i; i < controllersLength; ++i) {
+			address controller = _protocolControllers[i];
+			bytes32 protocol = _protocolNames[i];
+			if (controller == address(0)) revert ZeroAddress();
+			if (protocol == bytes32(0)) revert ZeroValue();
+
+			_whitelistProtocol(protocol, controller);
+		}
+	}
+
+	/**
+	 * @inheritdoc ICoreWhitelist
+	 */
+	function updateProtocolsControllers(
+		bytes32[] memory _protocolNames,
+		address[] memory _protocolControllers
+	) public virtual override {
+		uint256 controllersLength = _protocolControllers.length;
+
+		if (_protocolNames.length != controllersLength) revert ArraysLengthMismatch();
+		_nonEmptyArray(controllersLength);
+
+		address controller;
+		bytes32 protocol;
+		for (uint256 i; i < controllersLength; ++i) {
+			controller = _protocolControllers[i];
+			protocol = _protocolNames[i];
+			_updateProtocol(protocol, controller);
+		}
+	}
+
+	/**
+	 * @inheritdoc ICoreWhitelist
+	 */
+	function blacklistProtocols(bytes32[] memory _protocols) public virtual override {
+		uint256 protocolsLength = _protocols.length;
+		_nonEmptyArray(protocolsLength);
+
+		for (uint256 i; i < protocolsLength; ++i) {
+			bytes32 protocol = _protocols[i];
+			_blacklistProtocol(protocol);
+		}
+	}
+
+	/**
+	 * @inheritdoc ICoreWhitelist
+	 */
+	function getWhitelistedProtocols()
+		external
+		view
+		virtual
+		override
+		returns (bytes32[] memory protocols)
+	{
+		return __protocols.values();
+	}
+
+	/**
+	 * @inheritdoc ICoreWhitelist
+	 */
+	function isTokenWhitelisted(address token) public view returns (bool) {
+		return __tokens.contains(token);
+	}
+
+	function _whitelistTokens(AssetWithPriceFeed[] calldata tokens) internal {
+		uint256 length = tokens.length;
+		_nonEmptyArray(length);
+		address token;
+		uint8 decimals;
+		AssetWithPriceFeed memory assetInfo;
+		for (uint256 i; i < length; ++i) {
+			assetInfo = tokens[i];
+			token = assetInfo.assetAddr;
+			if (__tokens.add(token)) {
+				decimals = ERC20(token).decimals();
+				if (decimals != assetInfo.assetDec) revert DecimalsMismatch();
+				_tokenInfo[token] = assetInfo;
+				emit TokenAdded(assetInfo);
+			} else revert TokenAlreadyAdded(token);
+		}
+	}
+
+	function _blacklistTokens(address[] memory tokens) internal {
+		uint256 length = tokens.length;
+		_nonEmptyArray(length);
+		address token;
+		for (uint256 i; i < length; ++i) {
+			token = tokens[i];
+			if (__tokens.remove(token)) {
+				emit TokenRemoved(token);
+			} else revert TokenNotRemoved(token);
+		}
+	}
+
+	/**
+	 * @inheritdoc ICoreWhitelist
+	 */
+	function isProtocolWhitelisted(bytes32 _protocol) external view virtual override returns (bool) {
+		return _isProtocolWhitelisted(_protocol);
+	}
+
+	function _isProtocolWhitelisted(bytes32 _protocol) internal view returns (bool) {
+		return __protocols.contains(_protocol);
+	}
+
+	function _getWhitelistedProtocols() internal view returns (bytes32[] memory protocols) {
+		return __protocols.values();
+	}
+
+	function _whitelistProtocol(bytes32 _protocol, address _controller) internal {
+		if (__protocols.add(_protocol)) {
+			controllers[_protocol] = _controller;
+			emit ProtocolAdded(_protocol, _controller);
+		} else revert ActionAlreadyDone();
+	}
+
+	function _updateProtocol(
+		bytes32 _protocol,
+		address _controller
+	) internal nonZeroBytes32(_protocol) {
+		if (__protocols.contains(_protocol)) {
+			controllers[_protocol] = _controller;
+			emit ProtocolUpdated(_protocol, _controller);
+		} else revert ProtocolNotAllowed(_protocol);
+	}
+
+	function _blacklistProtocol(bytes32 _protocol) internal nonZeroBytes32(_protocol) {
+		if (__protocols.remove(_protocol)) {
+			delete controllers[_protocol];
+			emit ProtocolRemoved(_protocol, controllers[_protocol]);
+		} else revert ActionAlreadyDone();
+	}
+
+	uint256[50] private __gap;
+}

package/contracts/main/contracts/core/ICoreWhitelist.sol

@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+interface ICoreWhitelist {
+	struct FeedWithDecimal {
+		address feedAddr;
+		uint8 feedDec;
+	}
+	struct AssetWithPriceFeed {
+		address assetAddr;
+		uint8 assetDec;
+		FeedWithDecimal priceFeed;
+	}
+
+	/**
+	 * @notice Returns contoller address for the protocol
+	 * @param protocol - protocol to check
+	 * @return controller - controller address
+	 */
+	function controllers(bytes32 protocol) external view returns (address);
+
+	/**
+	 * @notice Returns array of whitelisted protocols
+	 * @return protocols - array of whitelisted protocols
+	 */
+	function getWhitelistedProtocols() external view returns (bytes32[] memory protocols);
+
+	/**
+	 * @notice Checks if contracts can use token
+	 * @param token - token to check
+	 * @return bool - `true` if token is whitelisted, `false` otherwise
+	 */
+	function isTokenWhitelisted(address token) external view returns (bool);
+
+	/**
+	 * @notice Returns token info
+	 * @param token - token to check
+	 * @return info - token info
+	 */
+	function tokenInfo(address token) external view returns (AssetWithPriceFeed memory info);
+
+	/**
+	 * @notice Checks if protocol is whitelisted and controller is allowed to use it
+	 * @param protocol - protocol to check
+	 * @return bool - `true` if protocol is whitelisted, `false` otherwise
+	 */
+	function isProtocolWhitelisted(bytes32 protocol) external view returns (bool);
+
+	/**
+	 * @notice Whitelists tokens for the system
+	 * @dev Emits `TokenAdded` event for each token
+	 *
+	 * @param tokens - array of tokens to whitelist
+	 */
+
+	function whitelistTokens(AssetWithPriceFeed[] calldata tokens) external;
+
+	/**
+	 * @notice Blacklists tokens from the system
+	 * @dev Emits TokenRemoved event for each token
+	 *
+	 * @param tokens Array of tokens to blacklist
+	 */
+	function blacklistTokens(address[] memory tokens) external;
+
+	/**
+	 * @notice Whitelists protocols for the system and sets their controllers
+	 * @param _protocolNames Array of protocols names
+	 * @param _protocolControllers Array of new protocols controllers addresses
+	 */
+	function whitelistProtocolsWithControllers(
+		bytes32[] memory _protocolNames,
+		address[] memory _protocolControllers
+	) external;
+
+	/**
+	 * @notice Updates the existing protocols controllers addresses
+	 * @param _protocolNames Array of protocols names
+	 * @param _protocolControllers Array of new protocols controllers addresses
+	 */
+	function updateProtocolsControllers(
+		bytes32[] memory _protocolNames,
+		address[] memory _protocolControllers
+	) external;
+
+	/**
+	 * @notice Removes protocols addresses from the controllers mapping
+	 * @param _protocols Array of protocols names
+	 */
+	function blacklistProtocols(bytes32[] memory _protocols) external;
+}

package/contracts/main/contracts/core/IUFarmCore.sol

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import {IFundFactory} from '../fund/FundFactory.sol';
+import {IPoolFactory} from '../pool/PoolFactory.sol';
+import {ICoreWhitelist} from './ICoreWhitelist.sol';
+
+interface IUFarmCore is ICoreWhitelist {
+	/**
+	 * @dev Returns the total number of funds in the UFarm ecosystem.
+	 */
+	function fundsCount() external view returns (uint256);
+
+	/**
+	 * @dev Retrieves the address of a specific fund by its index.
+	 */
+	function getFund(uint256) external view returns (address);
+
+	/**
+	 * @dev Checks if a given address is a recognized fund in the UFarm ecosystem.
+	 */
+	function isFund(address) external view returns (bool);
+
+	/**
+	 * @dev Returns the address of the price oracle used in the UFarm ecosystem.
+	 */
+	function priceOracle() external view returns (address);
+
+	/**
+	 * @dev Returns the instance of the FundFactory contract used by UFarm.
+	 */
+	function fundFactory() external view returns (IFundFactory);
+
+	/**
+	 * @dev Returns the instance of the PoolFactory contract used by UFarm.
+	 */
+	function poolFactory() external view returns (IPoolFactory);
+
+	/**
+	 * @dev Checks whether the UFarm protocol is currently paused.
+	 */
+	function isPaused() external view returns (bool);
+
+	/**
+	 * @dev Toggles the paused state of the UFarm protocol.
+	 */
+	function switchPause() external;
+
+	/**
+	 * @dev Retrieves the current protocol commission rate, expressed as a mantissa.
+	 */
+	function protocolCommission() external view returns (uint256);
+
+	/**
+	 * @dev Returns the minimum deposit amount required for a fund to be active.
+	 */
+	function minimumFundDeposit() external view returns (uint256);
+
+	/// GETTERS
+
+	/**
+	 * @dev Callable only by the UFarm member with `Moderator` permission
+	 * @param _fundManager - address of the fund manager
+	 * @param _applicationId - internal id of the application
+	 */
+	function createFund(address _fundManager, bytes32 _applicationId) external returns (address fund);
+
+	/**
+	 * @dev Sets the minimum fund deposit amount required for activating a Pool.
+	 * @param _minimumFundDeposit The minimum deposit amount in USDT.
+	 */
+	function setMinimumFundDeposit(uint256 _minimumFundDeposit) external;
+
+	/**
+	 * @dev Sets the protocol commission rate.
+	 * @param _protocolCommission The commission rate, expressed as a mantissa.
+	 */
+	function setProtocolCommission(uint256 _protocolCommission) external;
+
+	/**
+	 * @dev Updates the permissions for a specified UFarm member.
+	 * @param _member The address of the member whose permissions are to be updated.
+	 * @param _newPermissionsMask The new permissions mask to be applied.
+	 */
+	function updatePermissions(address _member, uint256 _newPermissionsMask) external;
+
+	/**
+	 * @notice Allows managers to withdraw assets from the contract
+	 * @dev Used to withdraw protocol commission. Arrays length should be equal
+	 * @param _tokens - array of tokens to withdraw
+	 * @param _amounts - array of amounts to withdraw
+	 */
+	function withdrawAssets(address[] calldata _tokens, uint256[] calldata _amounts) external;
+}