@oldzeppelin/contract 1.1.1

package/contracts/main/shared/AssetController.sol

@@ -0,0 +1,194 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import {EnumerableSet} from '@openzeppelin/contracts/utils/structs/EnumerableSet.sol';
+import {IERC20} from '@openzeppelin/contracts/token/ERC20/IERC20.sol';
+import {IERC721} from '@openzeppelin/contracts/token/ERC721/IERC721.sol';
+
+interface AssetsStructs {
+	struct ControlledERC20 {
+		address addr;
+		bytes32 controller;
+	}
+
+	struct ControlledERC721 {
+		address addr;
+		bytes32 controller;
+		uint256[] ids;
+	}
+
+	struct Assets {
+		uint256 totalWeight;
+		ERC20CommonAssets erc20;
+		ERC20ControlledAssets erc20Controlled;
+		ERC721ControlledAssets erc721Controlled;
+	}
+	struct ERC20CommonAssets {
+		EnumerableSet.AddressSet assets;
+	}
+	struct ERC20ControlledAssets {
+		EnumerableSet.AddressSet assets;
+		mapping(address => bytes32) controllers;
+	}
+	struct ERC721ControlledAssets {
+		EnumerableSet.AddressSet assets;
+		mapping(address => EnumerableSet.UintSet) idsOfAsset;
+		mapping(address => bytes32) controllers;
+	}
+}
+
+library AssetLib {
+	using EnumerableSet for EnumerableSet.AddressSet;
+	using EnumerableSet for EnumerableSet.UintSet;
+
+	uint256 internal constant COMMON_ERC20_WEIGHT = 1;
+	uint256 internal constant CONTROLLED_ERC20_WEIGHT = 2;
+	uint256 internal constant CONTROLLED_ERC721_WEIGHT = 5;
+
+	/**
+	 * @notice Returns the list of all ERC20 assets
+	 * @param _self - Assets struct
+	 */
+	function erc20CommonAssets(
+		AssetsStructs.Assets storage _self
+	) internal view returns (address[] memory tokenAssets) {
+		return _self.erc20.assets.values();
+	}
+
+	function erc20ControlledAssets(
+		AssetsStructs.Assets storage _self
+	) internal view returns (AssetsStructs.ControlledERC20[] memory liquidityAssetsERC20) {
+		AssetsStructs.ERC20ControlledAssets storage controlledERC20 = _self.erc20Controlled;
+		uint256 assetsLength = controlledERC20.assets.length();
+		liquidityAssetsERC20 = new AssetsStructs.ControlledERC20[](assetsLength);
+		address asset;
+		for (uint256 i; i < assetsLength; ++i) {
+			asset = controlledERC20.assets.at(i);
+			liquidityAssetsERC20[i] = AssetsStructs.ControlledERC20({
+				addr: asset,
+				controller: controlledERC20.controllers[asset]
+			});
+		}
+	}
+
+	function erc721ControlledAssets(
+		AssetsStructs.Assets storage _self
+	) internal view returns (AssetsStructs.ControlledERC721[] memory liquidityAssetsERC721) {
+		AssetsStructs.ERC721ControlledAssets storage controlledERC721 = _self.erc721Controlled;
+		uint256 assetsLength = controlledERC721.assets.length();
+		liquidityAssetsERC721 = new AssetsStructs.ControlledERC721[](assetsLength);
+		address asset;
+		for (uint256 i; i < assetsLength; ++i) {
+			asset = controlledERC721.assets.at(i);
+			liquidityAssetsERC721[i] = AssetsStructs.ControlledERC721({
+				addr: asset,
+				controller: controlledERC721.controllers[asset],
+				ids: controlledERC721.idsOfAsset[asset].values()
+			});
+		}
+	}
+
+	function addERC20(
+		AssetsStructs.Assets storage _self,
+		address _asset,
+		bytes32 _controller
+	) internal {
+		if (_controller > bytes32(0)) {
+			// return if asset already added to controlled list
+			if (_self.erc20.assets.contains(_asset)) return;
+
+			// add if balance > 0 and not added yet
+			if (
+				!_self.erc20Controlled.assets.contains(_asset) &&
+				IERC20(_asset).balanceOf(address(this)) > 0
+			) {
+				_self.erc20Controlled.assets.add(_asset);
+				_self.erc20Controlled.controllers[_asset] = _controller;
+				_self.totalWeight += CONTROLLED_ERC20_WEIGHT;
+			}
+		} else {
+			// return if asset already added to controlled assets list
+			if (_self.erc20Controlled.assets.contains(_asset)) return;
+
+			// add if balance > 0 and not added yet
+			if (!_self.erc20.assets.contains(_asset) && IERC20(_asset).balanceOf(address(this)) > 0) {
+				_self.erc20.assets.add(_asset);
+				_self.totalWeight += COMMON_ERC20_WEIGHT;
+			}
+		}
+	}
+
+	function removeERC20(AssetsStructs.Assets storage _self, address _asset) internal {
+		if (IERC20(_asset).balanceOf(address(this)) == 0) {
+			// removes asset if balance is 0
+			if (_self.erc20.assets.remove(_asset)) {
+				_self.totalWeight -= COMMON_ERC20_WEIGHT;
+			} else if (_self.erc20Controlled.assets.remove(_asset)) {
+				delete _self.erc20Controlled.controllers[_asset];
+				_self.totalWeight -= CONTROLLED_ERC20_WEIGHT;
+			}
+		}
+	}
+
+	function addERC721WithController(
+		AssetsStructs.Assets storage _self,
+		address _asset,
+		uint256[] memory _ids,
+		bytes32 _controller
+	) internal {
+		uint256 idsLength = _ids.length;
+		if (idsLength == 0 || IERC721(_asset).balanceOf(address(this)) == 0) return;
+
+		AssetsStructs.ERC721ControlledAssets storage erc721Controlled = _self.erc721Controlled;
+
+		bool atLeastOneAdded; // false by default
+		for (uint256 i; i < idsLength; ++i) {
+			if (
+				_checkERC721Ownership(_asset, _ids[i]) && erc721Controlled.idsOfAsset[_asset].add(_ids[i])
+			) {
+				_self.totalWeight += CONTROLLED_ERC721_WEIGHT;
+				if (!atLeastOneAdded) {
+					atLeastOneAdded = true;
+				}
+			} else continue;
+		}
+
+		if (atLeastOneAdded && !erc721Controlled.assets.contains(_asset)) {
+			erc721Controlled.assets.add(_asset);
+			erc721Controlled.controllers[_asset] = _controller;
+		}
+	}
+
+	function removeERC721WithController(
+		AssetsStructs.Assets storage _self,
+		address _asset,
+		uint256[] memory _ids
+	) internal {
+		uint256 toRemove;
+		AssetsStructs.ERC721ControlledAssets storage erc721Controlled = _self.erc721Controlled;
+		for (uint256 i; i < _ids.length; ++i) {
+			// skip if pool still owns this token
+			if (_checkERC721Ownership(_asset, _ids[i])) continue;
+			erc721Controlled.idsOfAsset[_asset].remove(_ids[i]);
+			toRemove++;
+		}
+		if (IERC721(_asset).balanceOf(address(this)) == 0) {
+			erc721Controlled.assets.remove(_asset);
+			delete erc721Controlled.controllers[_asset];
+			toRemove += erc721Controlled.idsOfAsset[_asset].length();
+			delete erc721Controlled.idsOfAsset[_asset];
+		}
+		_self.totalWeight -= toRemove * CONTROLLED_ERC721_WEIGHT;
+	}
+
+	/// solhint-disable-next-line no-unassigned-vars
+	function _checkERC721Ownership(address _asset, uint256 _id) private view returns (bool) {
+		// doesn't crash when token isn't exists
+		try IERC721(_asset).ownerOf(_id) returns (address owner) {
+			return owner == address(this);
+		} catch {
+			return false;
+		}
+	}
+}

package/contracts/main/shared/ECDSARecover.sol

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8;
+import {ECDSA} from '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';
+
+/**
+ * @title ECDSARecover
+ * @author https://ufarm.digital/
+ * @notice Contract that provides ECDSA signature recovery based on EIP712 standard
+ */
+abstract contract ECDSARecover {
+	struct EIP712Domain {
+		string name;
+		string version;
+		uint256 chainId;
+		address verifyingContract;
+	}
+
+	// Safe to use, because it is constant
+	/// @custom:oz-upgrades-unsafe-allow state-variable-assignment state-variable-immutable
+	bytes32 private immutable DOMAIN_STRUCTURE_HASH =
+		keccak256('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)');
+
+	/**
+	 * @notice EIP712 Domain Separator
+	 */
+	function DOMAIN_SEPARATOR() public view returns (bytes32) {
+		return
+			hashDomain(
+				EIP712Domain({
+					name: name(),
+					version: version(),
+					chainId: block.chainid,
+					verifyingContract: address(this)
+				})
+			);
+	}
+
+	/**
+	 * @notice Reverts if the provided signature was incorrectly formatted.
+	 */
+	error WrongSignature();
+
+	/**
+	 * @notice Returns the current version of the contract
+	 */
+	function version() public pure virtual returns (string memory);
+
+	/**
+	 * @notice Returns the name of the contract
+	 */
+	function name() public view virtual returns (string memory);
+
+	/**
+	 * @notice Computes EIP712 DOMAIN_SEPARATOR hash
+	 * @param domain - EIP712 domain struct
+	 */
+	function hashDomain(ECDSARecover.EIP712Domain memory domain) internal view returns (bytes32) {
+		return
+			keccak256(
+				abi.encode(
+					DOMAIN_STRUCTURE_HASH,
+					keccak256(bytes(domain.name)),
+					keccak256(bytes(domain.version)),
+					domain.chainId,
+					domain.verifyingContract
+				)
+			);
+	}
+
+	/**
+	 * @notice Recovers signer address from a message by using their signature
+	 * @param domainHash - hash of the EIP712 domain
+	 * @param msgHash - hash of the message
+	 */
+	function toEIP712MessageHash(
+		bytes32 domainHash,
+		bytes32 msgHash
+	) internal pure returns (bytes32) {
+		return keccak256(abi.encodePacked('\x19\x01', domainHash, msgHash));
+	}
+
+	/**
+	 * @notice Recovers signer address from a message by using their signature
+	 * @param digest - hash of the message
+	 * @param signature - signature of the hash
+	 */
+	function recoverAddress(bytes32 digest, bytes memory signature) internal pure returns (address) {
+		return ECDSA.recover(digest, signature);
+	}
+}

package/contracts/main/shared/NZGuard.sol

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+/// @title NZGuard contract contains modifiers to check inputs for non-zero address, non-zero value, non-same address, non-same value, and non-more-than-one
+abstract contract NZGuard {
+	error ZeroAddress();
+	error ZeroValue();
+	error EmptyArray();
+	error SameAddress();
+	error SameValue();
+	error MoreThanOne();
+	error ValueNotInRange(uint256 _value, uint256 _min, uint256 _max);
+
+	modifier nonZeroAddress(address _address) {
+		_nonZeroAddress(_address);
+		_;
+	}
+	modifier nonZeroValue(uint256 _value) {
+		_nonZeroValue(_value);
+		_;
+	}
+	modifier nonSameValue(uint256 _value1, uint256 _value2) {
+		_nonSameValue(_value1, _value2);
+		_;
+	}
+	modifier nonZeroBytes32(bytes32 _value) {
+		_nonZeroBytes32(_value);
+		_;
+	}
+	modifier nonSameAddress(address _address1, address _address2) {
+		_nonSameAddress(_address1, _address2);
+		_;
+	}
+	modifier nonMoreThenOne(uint256 _value) {
+		_nonMoreThenOne(_value);
+		_;
+	}
+	modifier nonEmptyArray(uint256 arrLength) {
+		_nonEmptyArray(arrLength);
+		_;
+	}
+	modifier valueInRange(
+		uint256 _value,
+		uint256 _min,
+		uint256 _max
+	) {
+		_valueInRange(_value, _min, _max);
+		_;
+	}
+
+	function _nonZeroAddress(address _address) internal pure {
+		if (_address == address(0)) {
+			revert ZeroAddress();
+		}
+	}
+
+	function _nonZeroValue(uint256 _value) internal pure {
+		if (_value == 0) {
+			revert ZeroValue();
+		}
+	}
+
+	function _nonZeroBytes32(bytes32 _value) internal pure {
+		if (_value == bytes32(0)) {
+			revert ZeroValue();
+		}
+	}
+
+	function _nonSameAddress(address _address1, address _address2) internal pure {
+		if (_address1 == _address2) {
+			revert SameAddress();
+		}
+	}
+
+	function _nonSameValue(uint256 _value1, uint256 _value2) internal pure {
+		if (_value1 == _value2) {
+			revert SameValue();
+		}
+	}
+
+	function _nonMoreThenOne(uint256 _value) internal pure {
+		if (_value > 1e18) {
+			revert MoreThanOne();
+		}
+	}
+
+	function _nonEmptyArray(uint256 arrLength) internal pure {
+		if (arrLength == 0) {
+			revert EmptyArray();
+		}
+	}
+
+	function _valueInRange(uint256 _value, uint256 _min, uint256 _max) internal pure {
+		if (_value < _min || _value > _max) {
+			revert ValueNotInRange(_value, _min, _max);
+		}
+	}
+}

package/contracts/main/shared/SafeOPS.sol

@@ -0,0 +1,128 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import {IERC20} from '@openzeppelin/contracts/token/ERC20/IERC20.sol';
+import {BeaconProxy} from '@openzeppelin/contracts/proxy/beacon/BeaconProxy.sol';
+
+/**
+ * @title SafeOPS
+ * @author https://ufarm.digital/
+ * @notice Contract module which provides a safe wrappers for some external calls
+ */
+library SafeOPS {
+	error DelegateCallFailed(address to);
+	error StaticCallFailed(address to);
+	error CallFailed(address to);
+	error ETHTransferFailed();
+	error BeaconProxyDeployFailed();
+
+	function _forceApprove(address token, address spender, uint256 value) internal {
+		bytes memory approvalCall = abi.encodeCall(IERC20.approve, (spender, value));
+
+		(bool success, ) = _safeCall(token, approvalCall);
+		if (!success) {
+			_safeCall(token, abi.encodeCall(IERC20.approve, (spender, 0)));
+			_safeCall(token, approvalCall);
+		}
+	}
+
+	function _safeCall(
+		address _to,
+		bytes memory _data
+	) internal returns (bool success, bytes memory result) {
+		(success, result) = _to.call(_data);
+		if (!success) {
+			if (result.length > 0) {
+				// solhint-disable-next-line no-inline-assembly
+				assembly {
+					let data_size := mload(result)
+					revert(add(32, result), data_size)
+				}
+			} else revert CallFailed(_to);
+		}
+	}
+
+	function _safeStaticCall(
+		address _to,
+		bytes calldata _data
+	) internal view returns (bool success, bytes memory result) {
+		(success, result) = _to.staticcall(_data);
+		if (!success) {
+			if (result.length > 0) {
+				// solhint-disable-next-line no-inline-assembly
+				assembly {
+					let data_size := mload(result)
+					revert(add(32, result), data_size)
+				}
+			} else revert StaticCallFailed(_to);
+		}
+	}
+
+	function _safeDelegateCall(
+		bool _ignoreRevert,
+		address _to,
+		bytes memory _data
+	) internal returns (bool success, bytes memory result) {
+		/// @custom:oz-upgrades-unsafe-allow delegatecall
+		(success, result) = _to.delegatecall(_data);
+		if (!success && !_ignoreRevert) {
+			if (result.length > 0) {
+				// solhint-disable-next-line no-inline-assembly
+				assembly {
+					let data_size := mload(result)
+					revert(add(32, result), data_size)
+				}
+			} else revert DelegateCallFailed(_to);
+		}
+	}
+
+	function _safeTransferETH(address _to, uint256 _amount) internal {
+		/// @solidity memory-safe-assembly
+		assembly {
+			if iszero(call(gas(), _to, _amount, gas(), 0x00, gas(), 0x00)) {
+				mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.
+				revert(0x1c, 0x04)
+			}
+		}
+	}
+
+	function _safeBeaconCreate2Deploy(
+		address _beacon,
+		bytes32 _salt,
+		bytes memory _initCall
+	) internal returns (address addr) {
+		try new BeaconProxy{salt: _salt}(_beacon, _initCall) returns (BeaconProxy beaconProxy) {
+			return address(beaconProxy);
+		} catch {
+			revert BeaconProxyDeployFailed();
+		}
+	}
+
+	function computeBeaconProxyAddress(
+		address _implBeacon,
+		bytes32 _salt,
+		bytes memory _initCall
+	) internal view returns (address addr) {
+		return
+			address(
+				uint160(
+					uint(
+						keccak256(
+							abi.encodePacked(
+								bytes1(0xff),
+								address(this),
+								_salt,
+								keccak256(
+									abi.encodePacked(
+										type(BeaconProxy).creationCode,
+										abi.encode(_implBeacon, _initCall)
+									)
+								)
+							)
+						)
+					)
+				)
+			);
+	}
+}

package/contracts/main/shared/UFarmCoreLink.sol

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+/**
+ * @title UFarmCoreLink interface
+ * @author https://ufarm.digital/
+ * @notice Interface for the UFarmCoreLink contract
+ */
+interface IUFarmCoreLink {
+	function coreCallback() external;
+}
+
+/**
+ * @title UFarmCoreLink contract
+ * @author https://ufarm.digital/
+ * @notice Sets ufarmCore link for contracts that deployed before than UFarmCore
+ */
+abstract contract UFarmCoreLink is IUFarmCoreLink {
+	/**
+	 * @notice Address of the UFarmCore contract
+	 */
+	function ufarmCore() public view returns (address) {
+		return _ufarmCore;
+	}
+
+	address private _ufarmCore;
+	/// @dev Keeps track of UFarmCore link approval
+	bool private linkApproved;
+
+	/**
+	 * @notice Emitted when UFarmCore address is set
+	 * @param ufarmCore Address of the UFarmCore contract
+	 */
+	event UFarmCoreLinkSet(address ufarmCore);
+
+	/**
+	 * @notice Reverts if UFarmCore address is not set
+	 */
+	error UFarmCoreLinkNotSet();
+	/**
+	 * @notice Reverts if UFarmCore address is not approved
+	 */
+	error UFarmCoreLinkNotApproved();
+
+	/**
+	 * @notice Reverts if UFarmCore address is not set
+	 */
+	modifier onlyLinked() {
+		if (!linkApproved) revert UFarmCoreLinkNotApproved();
+		_;
+	}
+
+	function __init__UFarmCoreLink(address ufarmCoreLink) internal  {
+		_setLink(ufarmCoreLink);
+	}
+
+	/**
+	 * @notice Callback function for UFarmCore contract
+	 * @dev UFarmCore contract calls this function during initialization to approve UFarmCore link
+	 */
+	function coreCallback() external override(IUFarmCoreLink) {
+		if (!linkApproved && msg.sender == _ufarmCore) {
+			linkApproved = true;
+			_coreCallbackHook();
+		} else revert UFarmCoreLinkNotApproved();
+	}
+
+	/// @dev override this function to add custom logic on UFarmCore callback
+	function _coreCallbackHook() internal virtual {}
+
+	/**
+	 * @notice Initializes UFarmCore link
+	 * @param ufarmCoreLink Address of the UFarmCore contract
+	 */
+	function _setLink(address ufarmCoreLink) internal {
+		_ufarmCore = ufarmCoreLink;
+
+		emit UFarmCoreLinkSet(ufarmCoreLink);
+	}
+
+	uint256[50] private __gap;
+}

package/contracts/main/shared/UFarmErrors.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+/**
+ * @title UFarmErrors contract
+ * @author https://ufarm.digital/
+ * @notice Stores shared errors for some UFarm contracts
+ */
+abstract contract UFarmErrors {
+	error ActionAlreadyDone();
+	error FETCHING_CONTROLLER_FAILED();
+	error ArraysLengthMismatch();
+	error UFarmIsPaused();
+	error NonAuthorized();
+}

package/contracts/main/shared/UFarmMathLib.sol

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.15;
+
+/**
+ * @title UFarmMathLib
+ * @dev Library for mathematical calculations used in UFarm contracts.
+ */
+library UFarmMathLib {
+	/**
+	 * @notice Converts an amount from one decimal format to another.
+	 * @param amount The amount to be converted.
+	 * @param fromDecimals The current decimal representation of the amount.
+	 * @param toDecimals The target decimal representation.
+	 * @return The amount converted to the target decimal format.
+	 */
+	function convertDecimals(
+		int256 amount,
+		uint8 fromDecimals,
+		uint8 toDecimals
+	) internal pure returns (int256) {
+		if (fromDecimals > toDecimals) {
+			return amount / int256(10 ** (fromDecimals - toDecimals));
+		} else if (fromDecimals < toDecimals) {
+			return amount * int256(10 ** (toDecimals - fromDecimals));
+		}
+		return amount;
+	}
+
+	/**
+	 * @notice Calculates the square root of a given number.
+	 * implementation from https://github.com/Uniswap/uniswap-lib/commit/99f3f28770640ba1bb1ff460ac7c5292fb8291a0
+	 * original implementation: https://github.com/abdk-consulting/abdk-libraries-solidity/blob/master/ABDKMath64x64.sol#L687
+	 * @param x - uint256
+	 */
+	function sqrt(uint256 x) internal pure returns (uint256) {
+		if (x == 0) return 0;
+		uint256 xx = x;
+		uint256 r = 1;
+
+		if (xx >= 0x100000000000000000000000000000000) {
+			xx >>= 128;
+			r <<= 64;
+		}
+
+		if (xx >= 0x10000000000000000) {
+			xx >>= 64;
+			r <<= 32;
+		}
+		if (xx >= 0x100000000) {
+			xx >>= 32;
+			r <<= 16;
+		}
+		if (xx >= 0x10000) {
+			xx >>= 16;
+			r <<= 8;
+		}
+		if (xx >= 0x100) {
+			xx >>= 8;
+			r <<= 4;
+		}
+		if (xx >= 0x10) {
+			xx >>= 4;
+			r <<= 2;
+		}
+		if (xx >= 0x8) {
+			r <<= 1;
+		}
+
+		r = (r + x / r) >> 1;
+		r = (r + x / r) >> 1;
+		r = (r + x / r) >> 1;
+		r = (r + x / r) >> 1;
+		r = (r + x / r) >> 1;
+		r = (r + x / r) >> 1;
+		r = (r + x / r) >> 1; // Seven iterations should be enough
+		uint256 r1 = x / r;
+		return (r < r1 ? r : r1);
+	}
+}