@oldzeppelin/contract 1.1.1

package/contracts/main/contracts/oracle/PriceOracleCore.sol

@@ -0,0 +1,212 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+/// CONTRACTS
+import {ChainlinkedOracle} from './ChainlinkedOracle.sol';
+import {UFarmCoreLink} from '../../shared/UFarmCoreLink.sol';
+import {UFarmOwnableUUPS} from '../../shared/UFarmOwnableUUPS.sol';
+
+/// INTERFACES
+import {IPriceOracle} from './IPriceOracle.sol';
+import {IERC20} from '@openzeppelin/contracts/token/ERC20/IERC20.sol';
+import {IERC721} from '@openzeppelin/contracts/token/ERC721/IERC721.sol';
+import {IUFarmPool} from '../pool/IUFarmPool.sol';
+import {IUFarmCore} from '../core/IUFarmCore.sol';
+import {ICoreWhitelist} from '../core/CoreWhitelist.sol';
+import {AggregatorV3Interface} from '@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol';
+import {IController, IERC20CommonController, IERC20SynthController, IERC721Controller} from '../controllers/IController.sol';
+import {AssetsStructs} from '../../shared/AssetController.sol';
+import {UFarmErrors} from '../../shared/UFarmErrors.sol';
+
+/// LIBRARIES
+import {UFarmMathLib} from '../../shared/UFarmMathLib.sol';
+
+/**
+ * @title PriceOracleCore contract
+ * @author https://ufarm.digital/
+ * @notice Connects to Chainlink price feeds and calculates the cost of assets
+ */
+abstract contract PriceOracleCore is
+	IPriceOracle,
+	UFarmCoreLink,
+	ChainlinkedOracle,
+	UFarmOwnableUUPS
+{
+	error InvalidPath();
+	error InvalidMethod();
+	error InvalidRecipient();
+	error InvalidController();
+
+	/**
+	 * @inheritdoc IPriceOracle
+	 */
+	function getCostERC20(
+		address tokenIn,
+		uint256 amountIn,
+		address tokenOut
+	) public view virtual returns (uint256 cost) {
+		(
+			ICoreWhitelist.AssetWithPriceFeed memory baseFeed,
+			ICoreWhitelist.AssetWithPriceFeed memory quoteFeed
+		) = (
+				ICoreWhitelist(ufarmCore()).tokenInfo(tokenIn),
+				ICoreWhitelist(ufarmCore()).tokenInfo(tokenOut)
+			);
+
+		if (baseFeed.priceFeed.feedAddr == address(0)) revert ChainlinkOracleNotSet(baseFeed.assetAddr);
+		if (quoteFeed.priceFeed.feedAddr == address(0))
+			revert ChainlinkOracleNotSet(quoteFeed.assetAddr);
+
+		(int256 basePrice, int256 quotePrice) = getNormalizedPrice(
+			baseFeed.priceFeed.feedAddr,
+			baseFeed.priceFeed.feedDec,
+			quoteFeed.priceFeed.feedAddr,
+			quoteFeed.priceFeed.feedDec
+		);
+
+		cost = uint256((int256(amountIn) * basePrice) / quotePrice);
+		cost = uint256(
+			UFarmMathLib.convertDecimals(int256(cost), baseFeed.assetDec, quoteFeed.assetDec)
+		);
+	}
+
+	/**
+	 * @notice Returns the normalized price of the base and quote tokens
+	 * @param _baseOracle - address of the base token's oracle
+	 * @param _baseOracleDecimals - decimals of the base oracle
+	 * @param _quoteOracle - address of the quote oracle
+	 * @param _quoteOracleDecimals - decimals of the quote token's oracle
+	 * @return basePrice - price of the base token
+	 * @return quotePrice - price of the quote token
+	 */
+	function getNormalizedPrice(
+		address _baseOracle,
+		uint8 _baseOracleDecimals,
+		address _quoteOracle,
+		uint8 _quoteOracleDecimals
+	) public view returns (int256 basePrice, int256 quotePrice) {
+		uint8 biggerDecimals = _baseOracleDecimals > _quoteOracleDecimals
+			? _baseOracleDecimals
+			: _quoteOracleDecimals;
+
+		basePrice = _chainlinkLatestAnswer(_baseOracle);
+		basePrice = UFarmMathLib.convertDecimals(basePrice, _baseOracleDecimals, biggerDecimals);
+
+		quotePrice = _chainlinkLatestAnswer(_quoteOracle);
+		quotePrice = UFarmMathLib.convertDecimals(quotePrice, _quoteOracleDecimals, biggerDecimals);
+
+		return (basePrice, quotePrice);
+	}
+
+	/**
+	 * @inheritdoc IPriceOracle
+	 */
+	function getCostControlledERC20(
+		address tokenIn,
+		uint256 amountIn,
+		address tokenOut,
+		address controller
+	) public view returns (uint256 cost) {
+		try IERC20SynthController(controller).getCostControlledERC20(tokenIn, amountIn, tokenOut) returns (uint256 cost20) {
+			cost = cost20;
+		} catch {
+			cost = 0;
+		}
+	}
+
+	/**
+	 * @inheritdoc IPriceOracle
+	 */
+	function getCostERC721(
+		address tokenIn,
+		uint256[] memory ids,
+		address tokenOut,
+		address controller
+	) public view returns (uint256 cost) {
+		try IERC721Controller(controller).getCostControlledERC721(tokenIn, ids, tokenOut) returns (uint256 cost721) {
+			cost = cost721;
+		} catch {
+			cost = 0;
+		}
+	}
+
+	/**
+	 * @notice Returns total cost of the pool in value token
+	 * @dev Doesn't check if pool is pool.
+	 * @param _ufarmPool - address of the pool
+	 * @param _valueToken - address of the value token
+	 */
+	function getTotalCostOfPool(
+		address _ufarmPool,
+		address _valueToken
+	) external view returns (uint256 totalCost) {
+		IUFarmPool pool = IUFarmPool(_ufarmPool);
+		IUFarmCore core = IUFarmCore(pool.ufarmCore());
+
+		// gas saving
+		uint256 length;
+		address thisAsset;
+		address controllerAddr;
+
+		// common erc20 block
+		{
+			address[] memory nonZeroAssets = pool.erc20CommonAssets();
+			length = nonZeroAssets.length;
+			uint256 balanceOfAsset;
+			for (uint256 i; i < length; ++i) {
+				thisAsset = nonZeroAssets[i];
+				balanceOfAsset = IERC20(thisAsset).balanceOf(_ufarmPool);
+				totalCost += thisAsset == _valueToken
+					? balanceOfAsset
+					: getCostERC20(thisAsset, balanceOfAsset, _valueToken);
+			}
+		}
+
+		// controlled erc20 block
+		{
+			AssetsStructs.ControlledERC20[] memory controlledAssets20 = pool.erc20ControlledAssets();
+			length = controlledAssets20.length;
+
+			for (uint256 i; i < length; ++i) {
+				thisAsset = controlledAssets20[i].addr;
+				controllerAddr = core.controllers(controlledAssets20[i].controller);
+				if (controllerAddr == address(0)) revert InvalidController();
+				totalCost += getCostControlledERC20(
+					thisAsset,
+					IERC20(thisAsset).balanceOf(_ufarmPool),
+					_valueToken,
+					controllerAddr
+				);
+			}
+		}
+
+		// controlled erc721 block
+		{
+			AssetsStructs.ControlledERC721[] memory controlledAssets721 = pool.erc721ControlledAssets();
+			length = controlledAssets721.length;
+
+			AssetsStructs.ControlledERC721 memory controlledAsset721;
+
+			for (uint256 i; i < length; ++i) {
+				controlledAsset721 = controlledAssets721[i];
+				controllerAddr = core.controllers(controlledAsset721.controller);
+				if (controllerAddr == address(0)) revert InvalidController();
+				totalCost += getCostERC721(
+					controlledAsset721.addr,
+					controlledAsset721.ids,
+					_valueToken,
+					controllerAddr
+				);
+			}
+		}
+	}
+
+	function __init__PriceOracleCore(address ufarmCoreLink) internal onlyInitializing {
+		__init__UFarmOwnableUUPS();
+		__init__UFarmCoreLink(ufarmCoreLink);
+		__init__ChainlinkedOracle(HOUR * 25); // 25 hours
+	}
+
+	uint256[50] private __gap;
+}

package/contracts/main/contracts/oracle/WstETHOracle.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import {ChainlinkedOracle} from './ChainlinkedOracle.sol';
+import {IChainlinkAggregator} from './IChainlinkAggregator.sol';
+
+/**
+ * @title WstETHOracle contract
+ * @author https://ufarm.digital/
+ * @notice Wraps the stETH/USD and wstETH/stETH Chainlink price feeds to query the wstETH/USD price
+ */
+contract WstETHOracle is IChainlinkAggregator, ChainlinkedOracle {
+	uint8 public immutable decimals;
+
+	address public immutable stETHUSDOracle;
+	address public immutable wstETHstETHOracle;
+	address public immutable wstETH;
+
+	constructor(address _wstETH, address _stETHUSDOracle, address _wstETHstETHOracle) initializer {
+		__init__ChainlinkedOracle(HOUR * 25);
+		stETHUSDOracle = _stETHUSDOracle;
+		wstETHstETHOracle = _wstETHstETHOracle;
+		wstETH = _wstETH;
+		decimals = IChainlinkAggregator(_stETHUSDOracle).decimals();
+	}
+
+	function latestAnswer() external view override returns (int256 answer) {
+		answer = _stETHtoWstETH(_chainlinkLatestAnswer(stETHUSDOracle));
+	}
+
+	function latestRoundData()
+		external
+		view
+		override
+		returns (
+			uint80 roundId,
+			int256 answer,
+			uint256 startedAt,
+			uint256 updatedAt,
+			uint80 answeredInRound
+		)
+	{
+		ChainlinkAnswer memory stETHRoundData = _chainlinkLatestRoundData(stETHUSDOracle);
+		answer = _stETHtoWstETH(stETHRoundData.answer);
+		return (
+			stETHRoundData.roundId,
+			answer,
+			stETHRoundData.startedAt,
+			stETHRoundData.updatedAt,
+			stETHRoundData.answeredInRound
+		);
+	}
+
+	function description() external pure returns (string memory) {
+		return 'UFarm WstETH/USD Oracle';
+	}
+
+	function _stETHtoWstETH(int256 _stETHUSDPrice) internal view returns (int256 wstETHUSDPrice) {
+		wstETHUSDPrice = _chainlinkLatestAnswer(wstETHstETHOracle);
+
+		return (wstETHUSDPrice * _stETHUSDPrice) / 10 ** 18;
+	}
+}

package/contracts/main/contracts/permissions/Permissions.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+interface Permissions {
+	enum Fund {
+		Member,
+		Owner,
+		UpdateFund,
+		InviteFundMember,
+		BlockFundMember,
+		UpdateFundPermissions,
+		CreatePool,
+		UpdatePoolDescription,
+		UpdatePoolPermissions,
+		PoolStatusControl,
+		UpdatePoolFees,
+		UpdatePoolTopUpAmount,
+		UpdateLockupPeriods,
+		ManageFund,
+		ApprovePoolTopup,
+		ApprovePoolWithdrawals,
+		ManagePoolFunds
+	}
+
+	enum Pool {
+		Member,
+		UpdatePoolDescription,
+		UpdatePoolPermissions,
+		PoolStatusControl,
+		UpdatePoolFees,
+		UpdatePoolTopUpAmount,
+		UpdateLockupPeriods,
+		ApprovePoolTopup,
+		ApprovePoolWithdrawals,
+		ManagePoolFunds
+	}
+
+	enum UFarm {
+		Member,
+		Owner,
+		UpdatePermissions,
+		UpdateUFarmMember,
+		DeleteUFarmMember,
+		ApproveFundCreation,
+		BlockFund,
+		BlockInvestor,
+		ManageFees,
+		ManageFundDeposit,
+		ManageWhitelist,
+		ManageAssets,
+		TurnPauseOn
+	}
+}

package/contracts/main/contracts/permissions/UFarmPermissionsModel.sol

@@ -0,0 +1,136 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import {UFarmErrors} from '../../shared/UFarmErrors.sol';
+
+/**
+ * @title UFarmPermissionsModel contract
+ * @author https://ufarm.digital/
+ * @notice Contract that implements permissions model for UFarm contracts
+ */
+abstract contract UFarmPermissionsModel {
+	uint256 internal constant _FULL_PERMISSIONS_MASK = type(uint256).max;
+	mapping(address => uint256) internal _accountMask;
+
+	// EVENTS
+	event PermissionsUpdated(address account, uint256 newPermissions);
+
+	// ERRORS
+	error PermissionAlreadyGranted(address account, uint256 permissions);
+
+	// MODIFIERS
+	/**
+	 * @notice Reverts if account has no required permissions
+	 * @param account - address to check permissions
+	 * @param permission1 - first permission to check
+	 * @param permission2 - second permission to check
+	 */
+	modifier shouldHaveTwoPermissions(
+		address account,
+		uint8 permission1,
+		uint8 permission2
+	) {
+		_checkForPermissions(account, _twoPermissionsToMask(permission1, permission2));
+		_;
+	}
+
+	// PUBLIC
+
+	/**
+	 * @notice Returns 'true' if account has required permission, 'false' otherwise
+	 * @param account - address to check permissions
+	 * @param permissionToCheck - permission to check
+	 */
+	function hasPermission(
+		address account,
+		uint8 permissionToCheck
+	) external view virtual returns (bool) {
+		return _hasPermission(account, permissionToCheck);
+	}
+
+	/**
+	 * @notice Returns 'true' if account has required permissions mask, 'false' otherwise
+	 * @param account - address to check permissions
+	 * @param permissionsToCheck - permissions mask to compare with
+	 */
+	function hasPermissionsMask(
+		address account,
+		uint256 permissionsToCheck
+	) external view virtual returns (bool) {
+		return __hasPermissions(_accountMask[account], permissionsToCheck);
+	}
+
+	/**
+	 * @notice Reverts if account has no required permissions mask
+	 * @param account - address to check permissions
+	 * @param permissionsToCheck - permissions mask to compare with
+	 */
+	function checkForPermissionsMask(
+		address account,
+		uint256 permissionsToCheck
+	) external view virtual {
+		_checkForPermissions(account, permissionsToCheck);
+	}
+
+	// INTERNAL SETTERS
+
+	function _updatePermissions(address account, uint256 newPermissions) internal {
+		if (_accountMask[account] != newPermissions) {
+			_accountMask[account] = newPermissions;
+			emit PermissionsUpdated(account, newPermissions);
+		} else {
+			revert PermissionAlreadyGranted(account, newPermissions);
+		}
+	}
+
+	// INTERNAL CHECKS
+
+	function _checkForPermissions(address account, uint256 permissions) internal view {
+		if (!__hasPermissions(_accountMask[account], permissions)) {
+			revert UFarmErrors.NonAuthorized();
+		}
+	}
+
+	// INTERNAL GETTERS
+
+	function _hasPermission(address account, uint8 permissionToCheck) internal view returns (bool) {
+		return (_accountMask[account] & (1 << permissionToCheck)) != 0;
+	}
+
+	function _maskHasPermission(uint256 mask, uint8 permissionToCheck) internal pure returns (bool) {
+		return (mask & (1 << permissionToCheck)) != 0;
+	}
+
+	function _hasPermissionMask(
+		address account,
+		uint256 permissionToCheck
+	) internal view returns (bool) {
+		return (_accountMask[account] & permissionToCheck) == permissionToCheck;
+	}
+
+	function _isPermissionDiff(
+		uint8 permission,
+		uint256 mask1,
+		uint256 mask2
+	) internal pure returns (bool) {
+		return ((mask1 & (1 << permission)) != (mask2 & (1 << permission)));
+	}
+
+	function _permissionToMask(uint8 permission) internal pure returns (uint256 mask) {
+		return (1 << permission);
+	}
+
+	function _twoPermissionsToMask(
+		uint8 permission1,
+		uint8 permission2
+	) internal pure returns (uint256 mask) {
+		return (1 << permission1) | (1 << permission2);
+	}
+
+	function __hasPermissions(uint256 accountPermissions, uint256 mask) private pure returns (bool) {
+		return (accountPermissions & mask) == mask;
+	}
+
+	uint256[50] private __gap;
+}

package/contracts/main/contracts/pool/IPoolAdmin.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+import {IUFarmPool} from './IUFarmPool.sol';
+import {Permissions} from '../permissions/Permissions.sol';
+
+pragma solidity ^0.8.0;
+
+interface IPoolAdmin {
+	struct PoolConfig {
+		uint256 managementCommission;
+		uint256 packedPerformanceFee;
+		uint256 minInvestment;
+		uint256 maxInvestment;
+		uint128 withdrawalLockupPeriod;
+	}
+
+	/**
+	 * @notice Initializes the pool admin contract during the pool creation
+	 * @param _settings - Pool parameters
+	 * @param _poolAddr - Address of the pool
+	 */
+	function __init_PoolAdmin(
+		IUFarmPool.CreationSettingsWithLinks memory _settings,
+		address _poolAddr
+	) external;
+
+	/**
+	 * @notice Returns pool configuration
+	 * @return config - PoolConfig struct
+	 */
+	function getConfig() external view returns (PoolConfig memory config);
+
+	/**
+	 * @notice Returns `true` if the caller has enough permissions to manage the pool funds
+	 * @param manager - Address of the fund manager
+	 * @return isAble - `true` if the caller has enough permissions to manage the pool funds
+	 */
+	function isAbleToManageFunds(address manager) external view returns (bool isAble);
+
+	/**
+	 * @notice Changes pool status on the connected UFarmPool contract
+	 * @param _newStatus - New pool status
+	 */
+	function changePoolStatus(IUFarmPool.PoolStatus _newStatus) external;
+
+	/**
+	 * @notice Reverts if the caller doesn't have pool permission or fund permission
+	 * @param _account - address of the account to check permissions
+	 * @param _poolPermission - permission in the pool
+	 * @param _fundPermission - permission in the fund
+	 */
+	function checkPoolOrFundPermission(
+		address _account,
+		Permissions.Pool _poolPermission,
+		Permissions.Fund _fundPermission
+	) external view;
+}