feat: update onBeforeMint logic to allow direct DEV staking

contracts/SimpleCollections.sol

@@ -6,6 +6,7 @@ import "@devprotocol/i-s-tokens/contracts/interfaces/ISTokensManagerStruct.sol";
 import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
 import "./interfaces/IProperty.sol";
 import "./interfaces/ISwapAndStake.sol";
+import "./utils/uniswapV3/libraries/OracleLibrary.sol";
 
 contract SimpleCollections is ITokenURIDescriptor, OwnableUpgradeable {
 	struct Image {
@@ -21,6 +22,9 @@ contract SimpleCollections is ITokenURIDescriptor, OwnableUpgradeable {
 	mapping(address => mapping(bytes32 => Image)) public propertyImages;
 	mapping(address => mapping(uint256 => uint256)) public stakedAmountAtMinted;
 
+	uint32 public lookbackSec = 300; // 5 minutes
+	address public devEthUniV3Pool;
+
 	function initialize(address _contract) external initializer {
 		__Ownable_init();
 		swapAndStake = ISwapAndStake(_contract);
@@ -36,6 +40,14 @@ contract SimpleCollections is ITokenURIDescriptor, OwnableUpgradeable {
 		swapAndStake = ISwapAndStake(_contract);
 	}
 
+	function setDevEthUniV3Pool(address _pool) external onlyOwner {
+		devEthUniV3Pool = _pool;
+	}
+
+	function setLookbackSec(uint32 _lookbackSec) external onlyOwner {
+		lookbackSec = _lookbackSec;
+	}
+
 	function image(
 		uint256 id,
 		address,
@@ -117,14 +129,41 @@ contract SimpleCollections is ITokenURIDescriptor, OwnableUpgradeable {
 			return false;
 		}
 
-		// Always only allow staking via the SwapAndStake contract.
-		ISwapAndStake.Amounts memory stakeVia = swapAndStake.gatewayOf(
-			img.gateway
-		);
-
 		// Validate the staking position.
-		bool valid = img.requiredETHAmount <= stakeVia.input &&
-			img.requiredETHFee <= stakeVia.fee;
+		bool valid = false;
+
+		// `requiredETHFee` will be 0 when using direct `DEV` otherwise it's assumed
+		// that input currency is `ETH`.
+		if (img.requiredETHFee > 0) {
+			// This condition validates input user ETH and fee.
+			// Always only allow staking via the SwapAndStake contract.
+			ISwapAndStake.Amounts memory stakeVia = swapAndStake.gatewayOf(
+				img.gateway
+			);
+
+			valid =
+				img.requiredETHAmount <= stakeVia.input &&
+				img.requiredETHFee <= stakeVia.fee;
+		} else {
+			// This condition validates input `DEV` equivalent `ETH` with required.
+
+			// Get the average price tick first
+			(int24 arithmeticMeanTick, ) = OracleLibrary.consult(
+				devEthUniV3Pool,
+				lookbackSec
+			);
+
+			// Get the quote for selling `DEV staked`. Assumes 1e18 for both.
+			// Fetch the `amount of ETH` the `DEV staked` is equal to.
+			uint256 equivalentETHStaked = OracleLibrary.getQuoteAtTick(
+				arithmeticMeanTick,
+				uint128(_positions.amount),
+				swapAndStake.devAddress(), // Fetch the `DEV token address` for this chain and setting from swapAndStake.
+				swapAndStake.wethAddress() // Fetch the `WETH token address` for this chain and setting from swapAndStake.
+			);
+
+			valid = img.requiredETHAmount <= equivalentETHStaked;
+		}
 
 		if (valid) {
 			stakedAmountAtMinted[_positions.property][id] = _positions.amount;

contracts/interfaces/ISwapAndStake.sol

@@ -8,5 +8,9 @@ interface ISwapAndStake {
 		uint256 fee;
 	}
 
+	function wethAddress() external view returns (address);
+
+	function devAddress() external view returns (address);
+
 	function gatewayOf(address _addr) external view returns (Amounts memory);
 }

contracts/utils/uniswapV3/interfaces/IUniswapV3Pool.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity 0.8.9;
+
+import "./pool/IUniswapV3PoolImmutables.sol";
+import "./pool/IUniswapV3PoolState.sol";
+import "./pool/IUniswapV3PoolDerivedState.sol";
+import "./pool/IUniswapV3PoolActions.sol";
+import "./pool/IUniswapV3PoolOwnerActions.sol";
+import "./pool/IUniswapV3PoolEvents.sol";
+
+/// @title The interface for a Uniswap V3 Pool
+/// @notice A Uniswap pool facilitates swapping and automated market making between any two assets that strictly conform
+/// to the ERC20 specification
+/// @dev The pool interface is broken up into many smaller pieces
+interface IUniswapV3Pool is
+	IUniswapV3PoolImmutables,
+	IUniswapV3PoolState,
+	IUniswapV3PoolDerivedState,
+	IUniswapV3PoolActions,
+	IUniswapV3PoolOwnerActions,
+	IUniswapV3PoolEvents
+{
+
+}

contracts/utils/uniswapV3/interfaces/pool/IUniswapV3PoolActions.sol

@@ -0,0 +1,105 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity 0.8.9;
+
+/// @title Permissionless pool actions
+/// @notice Contains pool methods that can be called by anyone
+interface IUniswapV3PoolActions {
+	/// @notice Sets the initial price for the pool
+	/// @dev Price is represented as a sqrt(amountToken1/amountToken0) Q64.96 value
+	/// @param sqrtPriceX96 the initial sqrt price of the pool as a Q64.96
+	function initialize(uint160 sqrtPriceX96) external;
+
+	/// @notice Adds liquidity for the given recipient/tickLower/tickUpper position
+	/// @dev The caller of this method receives a callback in the form of IUniswapV3MintCallback#uniswapV3MintCallback
+	/// in which they must pay any token0 or token1 owed for the liquidity. The amount of token0/token1 due depends
+	/// on tickLower, tickUpper, the amount of liquidity, and the current price.
+	/// @param recipient The address for which the liquidity will be created
+	/// @param tickLower The lower tick of the position in which to add liquidity
+	/// @param tickUpper The upper tick of the position in which to add liquidity
+	/// @param amount The amount of liquidity to mint
+	/// @param data Any data that should be passed through to the callback
+	/// @return amount0 The amount of token0 that was paid to mint the given amount of liquidity. Matches the value in the callback
+	/// @return amount1 The amount of token1 that was paid to mint the given amount of liquidity. Matches the value in the callback
+	function mint(
+		address recipient,
+		int24 tickLower,
+		int24 tickUpper,
+		uint128 amount,
+		bytes calldata data
+	) external returns (uint256 amount0, uint256 amount1);
+
+	/// @notice Collects tokens owed to a position
+	/// @dev Does not recompute fees earned, which must be done either via mint or burn of any amount of liquidity.
+	/// Collect must be called by the position owner. To withdraw only token0 or only token1, amount0Requested or
+	/// amount1Requested may be set to zero. To withdraw all tokens owed, caller may pass any value greater than the
+	/// actual tokens owed, e.g. type(uint128).max. Tokens owed may be from accumulated swap fees or burned liquidity.
+	/// @param recipient The address which should receive the fees collected
+	/// @param tickLower The lower tick of the position for which to collect fees
+	/// @param tickUpper The upper tick of the position for which to collect fees
+	/// @param amount0Requested How much token0 should be withdrawn from the fees owed
+	/// @param amount1Requested How much token1 should be withdrawn from the fees owed
+	/// @return amount0 The amount of fees collected in token0
+	/// @return amount1 The amount of fees collected in token1
+	function collect(
+		address recipient,
+		int24 tickLower,
+		int24 tickUpper,
+		uint128 amount0Requested,
+		uint128 amount1Requested
+	) external returns (uint128 amount0, uint128 amount1);
+
+	/// @notice Burn liquidity from the sender and account tokens owed for the liquidity to the position
+	/// @dev Can be used to trigger a recalculation of fees owed to a position by calling with an amount of 0
+	/// @dev Fees must be collected separately via a call to #collect
+	/// @param tickLower The lower tick of the position for which to burn liquidity
+	/// @param tickUpper The upper tick of the position for which to burn liquidity
+	/// @param amount How much liquidity to burn
+	/// @return amount0 The amount of token0 sent to the recipient
+	/// @return amount1 The amount of token1 sent to the recipient
+	function burn(
+		int24 tickLower,
+		int24 tickUpper,
+		uint128 amount
+	) external returns (uint256 amount0, uint256 amount1);
+
+	/// @notice Swap token0 for token1, or token1 for token0
+	/// @dev The caller of this method receives a callback in the form of IUniswapV3SwapCallback#uniswapV3SwapCallback
+	/// @param recipient The address to receive the output of the swap
+	/// @param zeroForOne The direction of the swap, true for token0 to token1, false for token1 to token0
+	/// @param amountSpecified The amount of the swap, which implicitly configures the swap as exact input (positive), or exact output (negative)
+	/// @param sqrtPriceLimitX96 The Q64.96 sqrt price limit. If zero for one, the price cannot be less than this
+	/// value after the swap. If one for zero, the price cannot be greater than this value after the swap
+	/// @param data Any data to be passed through to the callback
+	/// @return amount0 The delta of the balance of token0 of the pool, exact when negative, minimum when positive
+	/// @return amount1 The delta of the balance of token1 of the pool, exact when negative, minimum when positive
+	function swap(
+		address recipient,
+		bool zeroForOne,
+		int256 amountSpecified,
+		uint160 sqrtPriceLimitX96,
+		bytes calldata data
+	) external returns (int256 amount0, int256 amount1);
+
+	/// @notice Receive token0 and/or token1 and pay it back, plus a fee, in the callback
+	/// @dev The caller of this method receives a callback in the form of IUniswapV3FlashCallback#uniswapV3FlashCallback
+	/// @dev Can be used to donate underlying tokens pro-rata to currently in-range liquidity providers by calling
+	/// with 0 amount{0,1} and sending the donation amount(s) from the callback
+	/// @param recipient The address which will receive the token0 and token1 amounts
+	/// @param amount0 The amount of token0 to send
+	/// @param amount1 The amount of token1 to send
+	/// @param data Any data to be passed through to the callback
+	function flash(
+		address recipient,
+		uint256 amount0,
+		uint256 amount1,
+		bytes calldata data
+	) external;
+
+	/// @notice Increase the maximum number of price and liquidity observations that this pool will store
+	/// @dev This method is no-op if the pool already has an observationCardinalityNext greater than or equal to
+	/// the input observationCardinalityNext.
+	/// @param observationCardinalityNext The desired minimum number of observations for the pool to store
+	function increaseObservationCardinalityNext(
+		uint16 observationCardinalityNext
+	) external;
+}

contracts/utils/uniswapV3/interfaces/pool/IUniswapV3PoolDerivedState.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity 0.8.9;
+
+/// @title Pool state that is not stored
+/// @notice Contains view functions to provide information about the pool that is computed rather than stored on the
+/// blockchain. The functions here may have variable gas costs.
+interface IUniswapV3PoolDerivedState {
+	/// @notice Returns the cumulative tick and liquidity as of each timestamp `secondsAgo` from the current block timestamp
+	/// @dev To get a time weighted average tick or liquidity-in-range, you must call this with two values, one representing
+	/// the beginning of the period and another for the end of the period. E.g., to get the last hour time-weighted average tick,
+	/// you must call it with secondsAgos = [3600, 0].
+	/// @dev The time weighted average tick represents the geometric time weighted average price of the pool, in
+	/// log base sqrt(1.0001) of token1 / token0. The TickMath library can be used to go from a tick value to a ratio.
+	/// @param secondsAgos From how long ago each cumulative tick and liquidity value should be returned
+	/// @return tickCumulatives Cumulative tick values as of each `secondsAgos` from the current block timestamp
+	/// @return secondsPerLiquidityCumulativeX128s Cumulative seconds per liquidity-in-range value as of each `secondsAgos` from the current block
+	/// timestamp
+	function observe(
+		uint32[] calldata secondsAgos
+	)
+		external
+		view
+		returns (
+			int56[] memory tickCumulatives,
+			uint160[] memory secondsPerLiquidityCumulativeX128s
+		);
+
+	/// @notice Returns a snapshot of the tick cumulative, seconds per liquidity and seconds inside a tick range
+	/// @dev Snapshots must only be compared to other snapshots, taken over a period for which a position existed.
+	/// I.e., snapshots cannot be compared if a position is not held for the entire period between when the first
+	/// snapshot is taken and the second snapshot is taken.
+	/// @param tickLower The lower tick of the range
+	/// @param tickUpper The upper tick of the range
+	/// @return tickCumulativeInside The snapshot of the tick accumulator for the range
+	/// @return secondsPerLiquidityInsideX128 The snapshot of seconds per liquidity for the range
+	/// @return secondsInside The snapshot of seconds per liquidity for the range
+	function snapshotCumulativesInside(
+		int24 tickLower,
+		int24 tickUpper
+	)
+		external
+		view
+		returns (
+			int56 tickCumulativeInside,
+			uint160 secondsPerLiquidityInsideX128,
+			uint32 secondsInside
+		);
+}