@oldzeppelin/contract 1.1.1

package/contracts/main/shared/UFarmOwnableUUPS.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+/// CONTRACTS
+import {UFarmErrors} from './UFarmErrors.sol';
+import {NZGuard} from './NZGuard.sol';
+import {OwnableUpgradeable} from '@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol';
+import {UUPSUpgradeable} from '@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol';
+
+/**
+ * @title UFarmOwnableUUPS contract
+ * @author https://ufarm.digital/
+ * @notice UUPS + Ownable contract for permissioned upgrades
+ */
+abstract contract UFarmOwnableUUPS is OwnableUpgradeable, UUPSUpgradeable {
+	/// @dev Address of the contract deployer, used for delayed permissioned initialization
+	/// @custom:oz-upgrades-unsafe-allow state-variable-assignment state-variable-immutable
+	address private immutable _deployer = msg.sender;
+	/// @custom:oz-upgrades-unsafe-allow state-variable-assignment state-variable-immutable
+	address private immutable __self = address(this);
+
+	/**
+	 * @dev Error thrown when a function is called without delegatecall.
+	 */
+	error NotDelegateCalled();
+
+	/**
+	 * @dev Modifier to check if function is called via delegatecall.
+	 */
+	modifier checkDelegateCall() {
+		if (address(this) == __self) revert NotDelegateCalled();
+		_;
+	}
+	/**
+	 * @dev Modifier to check if function is called by the deployer.
+	 */
+	modifier onlyDeployer() {
+		if (msg.sender != _deployer) revert UFarmErrors.NonAuthorized();
+		_;
+	}
+
+	/**
+	 * @notice Prohibits renouncing ownership to prevent potential state with no owner
+	 */
+	function renounceOwnership() public pure override {
+		revert UFarmErrors.NonAuthorized();
+	}
+
+	function __init__UFarmOwnableUUPS() internal virtual onlyInitializing {
+		__Ownable_init();
+	}
+
+	function __init_UFarmOwnableUUPS_unchained() internal virtual onlyInitializing {}
+
+	function _authorizeUpgrade(address newImplementation) internal virtual override onlyOwner {}
+
+	uint256[50] private __gap;
+}

package/contracts/main/shared/UFarmOwnableUUPSBeacon.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import {UFarmOwnableUUPS} from './UFarmOwnableUUPS.sol';
+// import {IBeaconUpgradeable} from '@openzeppelin/contracts-upgradeable/proxy/beacon/IBeaconUpgradeable.sol';
+
+/**
+ * @title UFarmOwnableUUPSBeacon contract
+ * @author https://ufarm.digital/
+ * @notice Prohibits implementation upgrades from proxy, only external called upgrades are allowed
+ */
+abstract contract UFarmOwnableUUPSBeacon is UFarmOwnableUUPS {
+	/**
+	 * @dev Upgrade the implementation of the proxy to `newImplementation`.
+	 * Upgrades only the implementation, not the beacon proxy
+	 * @custom:oz-upgrades-unsafe-allow-reachable delegatecall
+	 */
+	function upgradeTo(address newImplementation) public virtual override onlyProxy notDelegated {
+		_authorizeUpgrade(newImplementation);
+		_upgradeToAndCallUUPS(newImplementation, new bytes(0), false);
+	}
+
+	function __init_UFarmOwnableUUPSBeacon() internal virtual onlyInitializing {
+		__init__UFarmOwnableUUPS();
+		__init_UFarmOwnableUUPSBeacon_unchained();
+	}
+
+	function __init_UFarmOwnableUUPSBeacon_unchained() internal virtual onlyInitializing {
+		_transferOwnership(address(0)); // Implementation is UFarmOwnableUUPS, so Beacon should not have an owner
+	}
+
+	uint256[50] private __gap;
+}

package/contracts/test/Block.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+contract Block {
+	uint256 blockNumber;
+
+	function setBlockNumber(uint256 _blockNumber) public {
+		blockNumber = _blockNumber;
+	}
+
+    function getBlockTimestamp() public view returns (uint256) {
+        return block.timestamp;
+    }
+}

package/contracts/test/InchSwapTestProxy.sol

@@ -0,0 +1,292 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import {IUFarmCore} from '../main/contracts/core/IUFarmCore.sol';
+import {IERC20} from '@openzeppelin/contracts/token/ERC20/IERC20.sol';
+
+/// LIBRARIES
+import {EnumerableSet} from '@openzeppelin/contracts/utils/structs/EnumerableSet.sol';
+import {SafeOPS} from '../main/shared/SafeOPS.sol';
+import {SafeERC20} from '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
+
+import {UFarmErrors} from '../main/shared/UFarmErrors.sol';
+import {NZGuard} from '../main/shared/NZGuard.sol';
+import {Controller, IController} from '../main/contracts/controllers/Controller.sol';
+import {SafeOPS} from '../main/shared/SafeOPS.sol';
+import {IUniswapV2Pair} from './Uniswap/contracts/v2-core/contracts/interfaces/IUniswapV2Pair.sol';
+import {BytesLib} from './UniswapV3/@uniswap/v3-periphery/contracts/libraries/BytesLib.sol';
+
+interface IAggregationExecutor {
+	/// @notice propagates information about original msg.sender and executes arbitrary data
+	function execute(address msgSender) external payable; // 0x4b64e492
+}
+
+interface IAggregationRouterV5 {
+	struct SwapDescription {
+		address srcToken;
+		address dstToken;
+		address payable srcReceiver;
+		address payable dstReceiver;
+		uint256 amount;
+		uint256 minReturnAmount;
+		uint256 flags;
+	}
+
+	function swap(
+		IAggregationExecutor executor,
+		SwapDescription calldata desc,
+		bytes calldata permit,
+		bytes calldata data
+	) external payable returns (uint256 returnAmount, uint256 spentAmount);
+
+	function unoswap(
+		address srcToken,
+		uint256 amount,
+		uint256 minReturn,
+		uint256[] calldata pools
+	) external payable returns (uint256 returnAmount);
+
+	function unoswapTo(
+		address payable recipient,
+		IERC20 srcToken,
+		uint256 amount,
+		uint256 minReturn,
+		uint256[] calldata pools
+	) external payable returns (uint256 returnAmount);
+
+	function uniswapV3Swap(
+		uint256 amount,
+		uint256 minReturn,
+		uint256[] calldata pools
+	) external payable returns (uint256 returnAmount);
+
+	function uniswapV3SwapTo(
+		address payable recipient,
+		uint256 amount,
+		uint256 minReturn,
+		uint256[] calldata pools
+	) external payable returns (uint256 returnAmount);
+}
+
+interface IUniswapV3Pool {
+	function token0() external view returns (address);
+
+	function token1() external view returns (address);
+}
+
+contract InchSwapTestProxy {
+	mapping(bytes32 => address) public controllers;
+
+	function addController(bytes32 _protocol, address _controller) external {
+		controllers[_protocol] = _controller;
+	}
+
+	function justCall(address token, address callAddr, bytes calldata callData) public {
+		SafeOPS._forceApprove(token, callAddr, 1000 * 1 ether);
+		(bool success, bytes memory result) = callAddr.call(callData);
+	}
+
+	function protocolAction(bytes32 _protocol, bytes calldata _data) external {
+		_protocolAction(false, controllers[_protocol], _protocol, address(this), _data);
+	}
+
+	function _protocolAction(
+		bool _ignoreRevert,
+		address _controllerAddr,
+		bytes32 _protocolHash,
+		address _target,
+		bytes memory _data
+	) private {
+		SafeOPS._safeDelegateCall(_ignoreRevert, _controllerAddr, _data);
+	}
+
+	function executeAny(address _target, bytes calldata _data) external {
+		(bool success, bytes memory result) = _target.delegatecall(_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('Call failed');
+		}
+	}
+}
+
+contract InchSwapTestController is Controller, NZGuard, UFarmErrors {
+	using BytesLib for bytes;
+
+	bytes32 internal constant _PROTOCOL = keccak256(abi.encodePacked('OneInchV5')); // Needs to be hardcoded in the contract to use it during delegation
+
+	address public aggregationRouterV5;
+	address public immutable thisAddr;
+
+	constructor(address _aggregationRouterV5) {
+		aggregationRouterV5 = _aggregationRouterV5;
+		thisAddr = address(this);
+	}
+
+	/**
+	 * @notice Delegates swap to 1inch V5 aggregation router
+	 * @param tokenIn - token to swap from
+	 * @param tokenOut - token to swap to
+	 * @param amountIn - amount of tokenIn to swap
+	 * @param amountOut - minimum amount of tokenOut to receive
+	 * @param protocol - protocol hashed name
+	 */
+	event SwapOneInchV5(
+		address indexed tokenIn,
+		address indexed tokenOut,
+		uint256 amountIn,
+		uint256 amountOut,
+		bytes32 protocol
+	);
+
+	error InvalidPath();
+	error InvalidMethod(bytes4 method);
+	error InvalidRecipient();
+	error OneInchSwapFailed();
+
+	/**
+	 * @inheritdoc IController
+	 */
+	function PROTOCOL() public pure override returns (bytes32) {
+		return _PROTOCOL;
+	}
+
+	// IAggregationRouterV5.unoswap(srcToken: 0xdAC17F958D2ee523a2206206994597C13D831ec7, amount: 996999, minReturn: 988205, pools: [57896044618658097713242609637998371593005199524156639266814448023762806431658])
+	// OneInchV5Controller.delegated1InchSwap(_data: 0x0502b1c5000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec700000000000000000000000000000000000000000000000000000000000f368700000000000000000000000000000000000000000000000000000000000f142d0000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000180000000000000003b6d0340d86a120a06255df8d4e2248ab04d4267e23adfaa8b1ccac8)
+	function delegated1InchSwap(bytes memory _data) external checkDelegateCall {
+		bytes4 method;
+		assembly {
+			method := mload(add(_data, 32)) // load first 4 bytes of data
+		}
+
+		uint256[] memory pools;
+		address srcToken;
+		address payable recipient;
+		uint256 amountIn;
+		uint256 amountOut;
+		address tokenIn;
+		address tokenOut;
+
+		if (method == IAggregationRouterV5.unoswapTo.selector) {
+			(recipient, srcToken, amountIn, amountOut, pools) = abi.decode(
+				_data.slice(4, _data.length - 4),
+				(address, address, uint256, uint256, uint256[])
+			);
+
+			if (recipient != address(this)) revert InvalidRecipient();
+
+			tokenIn = srcToken;
+
+			// _onlyIfTokenAllowed(srcToken);
+
+			address v2Pool;
+			for (uint256 i; i < pools.length; ++i) {
+				v2Pool = address(uint160(pools[i]));
+
+				(address token0, address token1) = (
+					IUniswapV2Pair(v2Pool).token0(),
+					IUniswapV2Pair(v2Pool).token1()
+				);
+
+				if (token0 == srcToken) {
+					// _onlyIfTokenAllowed(token1);
+					srcToken = token1;
+				} else if (token1 == srcToken) {
+					// _onlyIfTokenAllowed(token0);
+					srcToken = token0;
+				} else revert InvalidPath();
+			}
+			tokenOut = srcToken;
+		} else if (method == IAggregationRouterV5.uniswapV3SwapTo.selector) {
+			(recipient, amountIn, amountOut, pools) = abi.decode(
+				_data.slice(4, _data.length - 4),
+				(address, uint256, uint256, uint256[])
+			);
+
+			if (recipient != address(this)) revert InvalidRecipient();
+
+			uint256 length = pools.length;
+			for (uint256 i; i < length; ++i) {
+				address v2Pool = address(uint160(pools[i]));
+
+				bool zeroForOne = pools[0] & (1 << 255) == 0;
+
+				(address token0, address token1) = (
+					IUniswapV3Pool(v2Pool).token0(),
+					IUniswapV3Pool(v2Pool).token1()
+				);
+				if (i == 0) {
+					if (length == 1) {
+						tokenOut = zeroForOne ? token1 : token0;
+						// _onlyIfTokenAllowed(tokenOut);
+					}
+					// check src token
+					tokenIn = zeroForOne ? token0 : token1;
+					// _onlyIfTokenAllowed(tokenIn);
+				} else if (i < length) {
+					// check next dst token
+					// _onlyIfTokenAllowed(zeroForOne ? token1 : token0);
+				} else {
+					// check dst token
+					tokenOut = zeroForOne ? token1 : token0;
+					// _onlyIfTokenAllowed(tokenOut);
+				}
+			}
+		} else if (method == IAggregationRouterV5.unoswap.selector) {
+			(srcToken, amountIn, amountOut, pools) = abi.decode(
+				_data.slice(4, _data.length - 4),
+				(address, uint256, uint256, uint256[])
+			);
+
+			tokenIn = srcToken;
+
+			// _onlyIfTokenAllowed(srcToken);
+
+			address v2Pool;
+			for (uint256 i; i < pools.length; ++i) {
+				v2Pool = address(uint160(pools[i]));
+
+				(address token0, address token1) = (
+					IUniswapV2Pair(v2Pool).token0(),
+					IUniswapV2Pair(v2Pool).token1()
+				);
+
+				if (token0 == srcToken) {
+					// _onlyIfTokenAllowed(token1);
+					srcToken = token1;
+				} else if (token1 == srcToken) {
+					// _onlyIfTokenAllowed(token0);
+					srcToken = token0;
+				} else revert InvalidPath();
+			}
+			tokenOut = srcToken;
+		} else revert InvalidMethod(method);
+
+		address _aggregRouter = InchSwapTestController(payable(thisAddr)).aggregationRouterV5();
+
+		if (amountIn == 0 || amountOut == 0) revert OneInchSwapFailed();
+
+		SafeOPS._forceApprove(tokenIn, _aggregRouter, amountIn);
+
+		// uint256 balanceIn = IERC20(tokenIn).balanceOf(address(this));
+
+		// emit Data(_data);
+
+		(, bytes memory result) = SafeOPS._safeCall(_aggregRouter, _data);
+
+		uint256 amountOutResult;
+		assembly {
+			// return amount should be in 0x20 offset from any result
+			amountOutResult := mload(add(result, 0x20))
+		}
+
+		if (amountOutResult < amountOut) revert OneInchSwapFailed();
+
+		emit SwapOneInchV5(tokenIn, tokenOut, amountIn, amountOutResult, PROTOCOL());
+	}
+}

package/contracts/test/MockPoolAdmin.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import '../../contracts/main/contracts/pool/PoolAdmin.sol';
+import './Block.sol';
+
+contract MockPoolAdmin is PoolAdmin, Block {}

package/contracts/test/MockUFarmPool.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import '../../contracts/main/contracts/pool/UFarmPool.sol';
+import './Block.sol';
+
+contract MockUFarmPool is UFarmPool, Block {}

package/contracts/test/MockV3wstETHstETHAgg.sol

@@ -0,0 +1,128 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+import {AggregatorV2V3Interface} from '@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol';
+import {IUniswapV2Router02} from './Uniswap/contracts/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol';
+import {ERC20} from '@oldzeppelin/contracts/token/ERC20/ERC20.sol';
+import {UFarmMathLib} from '../main/shared/UFarmMathLib.sol';
+import {IWstETH8, IStETH8} from '../test/lido/contracts/IWstETH8.sol';
+
+/**
+ * @title MockV3wstETHstETHAgg
+ * @notice Based on the @chainlink/contracts/src/v0.8/tests/MockV3Aggregator.sol
+ */
+contract MockV3wstETHstETHAgg is AggregatorV2V3Interface {
+	uint256 public constant override version = 0;
+
+	uint8 public immutable override decimals;
+	IStETH8 public immutable stETH;
+	IWstETH8 public immutable wstETH;
+
+	int256 public override latestAnswer;
+	uint256 public override latestTimestamp;
+	uint256 public override latestRound;
+
+	mapping(uint256 => int256) public override getAnswer;
+	mapping(uint256 => uint256) public override getTimestamp;
+	mapping(uint256 => uint256) private getStartedAt;
+
+	constructor(IWstETH8 _wstETH) {
+		decimals = 18;
+		wstETH = _wstETH;
+		stETH = IStETH8(_wstETH.stETH());
+		updateAnswer(getChainlinkFormattedPrice());
+	}
+
+	function getChainlinkFormattedPrice() public view returns (int256 chainlinkPrice) {
+		return int256(wstETH.stEthPerToken());
+	}
+
+	function _answerStETHToWstETH(int256 _stETHPrice) internal view returns (int256) {
+		int256 wstETH_stETHPrice = int256(wstETH.stEthPerToken());
+		return (_stETHPrice * wstETH_stETHPrice) / 10 ** 18;
+	}
+
+	function updateAnswerWithChainlinkPrice() public {
+		updateAnswer(getChainlinkFormattedPrice());
+	}
+
+	function updateAnswer(int256 _answer) public {
+		latestAnswer = _answer;
+		latestTimestamp = block.timestamp;
+		latestRound++;
+		getAnswer[latestRound] = _answer;
+		getTimestamp[latestRound] = block.timestamp;
+		getStartedAt[latestRound] = block.timestamp;
+	}
+
+	function updateRoundData(
+		uint80 _roundId,
+		int256 _answer,
+		uint256 _timestamp,
+		uint256 _startedAt
+	) public {
+		latestRound = _roundId;
+		latestAnswer = _answer;
+		latestTimestamp = _timestamp;
+		getAnswer[latestRound] = _answer;
+		getTimestamp[latestRound] = _timestamp;
+		getStartedAt[latestRound] = _startedAt;
+	}
+
+	function getRoundData(
+		uint80 _roundId
+	)
+		external
+		view
+		override
+		returns (
+			uint80 roundId,
+			int256 answer,
+			uint256 startedAt,
+			uint256 updatedAt,
+			uint80 answeredInRound
+		)
+	{
+		return (
+			_roundId,
+			getAnswer[_roundId],
+			getStartedAt[_roundId],
+			getTimestamp[_roundId],
+			_roundId
+		);
+	}
+
+	function latestRoundData()
+		external
+		view
+		override
+		returns (
+			uint80 roundId,
+			int256 answer,
+			uint256 startedAt,
+			uint256 updatedAt,
+			uint80 answeredInRound
+		)
+	{
+		answer = getChainlinkFormattedPrice();
+		uint80 updateTime = uint80(block.timestamp - 600);
+		// return (
+		// 	uint80(latestRound),
+		// 	getAnswer[latestRound],
+		// 	getStartedAt[latestRound],
+		// 	getTimestamp[latestRound],
+		// 	uint80(latestRound)
+		// );
+		return (
+			uint80(block.timestamp),
+			answer,
+			getStartedAt[latestRound],
+			updateTime,
+			uint80(latestRound)
+		);
+	}
+
+	function description() external pure override returns (string memory) {
+		return 'v0.8/tests/MockV3Aggregator.sol';
+	}
+}

package/contracts/test/MockedWETH9.sol

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity =0.6.6;
+
+contract MockedWETH9 {
+	string public name = 'Wrapped Ether';
+	string public symbol = 'WETH';
+	uint8 public decimals = 18;
+
+	event Approval(address indexed src, address indexed guy, uint wad);
+	event Transfer(address indexed src, address indexed dst, uint wad);
+	event Deposit(address indexed dst, uint wad);
+	event Withdrawal(address indexed src, uint wad);
+
+	mapping(address => uint) public balanceOf;
+	mapping(address => mapping(address => uint)) public allowance;
+
+	function deposit() public payable {
+		uint256 toDeposit = msg.value * 1 ether;
+		balanceOf[msg.sender] += toDeposit;
+		emit Deposit(msg.sender, toDeposit);
+	}
+
+	function withdraw(uint wad) public {
+		require(balanceOf[msg.sender] >= wad, '');
+		balanceOf[msg.sender] -= wad;
+		uint256 toWithdraw = wad / 1 ether;
+		if (toWithdraw > 0) {
+			msg.sender.transfer(toWithdraw);
+		}
+		emit Withdrawal(msg.sender, wad);
+	}
+
+	function totalSupply() public view returns (uint) {
+		return address(this).balance;
+	}
+
+	function approve(address guy, uint wad) public returns (bool) {
+		allowance[msg.sender][guy] = wad;
+		emit Approval(msg.sender, guy, wad);
+		return true;
+	}
+
+	function transfer(address dst, uint wad) public returns (bool) {
+		return transferFrom(msg.sender, dst, wad);
+	}
+
+	function transferFrom(address src, address dst, uint wad) public returns (bool) {
+		require(balanceOf[src] >= wad, '');
+
+		if (src != msg.sender && allowance[src][msg.sender] != uint(-1)) {
+			require(allowance[src][msg.sender] >= wad, '');
+			allowance[src][msg.sender] -= wad;
+		}
+
+		balanceOf[src] -= wad;
+		balanceOf[dst] += wad;
+
+		emit Transfer(src, dst, wad);
+
+		return true;
+	}
+
+	function mintWeth(address guy, uint wad) public {
+		balanceOf[guy] += wad;
+		emit Deposit(guy, wad);
+	}
+
+	function burnWeth(address guy, uint wad) public {
+		balanceOf[guy] -= wad;
+		emit Withdrawal(guy, wad);
+	}
+}