Add RehypothecationHook

.gitmodules

@@ -6,7 +6,7 @@
 	url = https://github.com/Uniswap/v4-core
 [submodule "lib/v4-periphery"]
 	path = lib/v4-periphery
-	url = https://github.com/Uniswap/v4-periphery
+	url = https://github.com/uniswap/v4-periphery
 [submodule "lib/openzeppelin-contracts"]
 	path = lib/openzeppelin-contracts
 	url = https://github.com/OpenZeppelin/openzeppelin-contracts

remappings.txt

@@ -1,4 +1,4 @@
 forge-std/=lib/forge-std/src/
 @uniswap/v4-core/=lib/v4-core/
 @uniswap/v4-periphery/=lib/v4-periphery/
-@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/
+@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/

src/general/README.adoc

@@ -8,9 +8,11 @@ Ready-to-use hooks built on top of the base and fee abstract contracts
  * {LiquidityPenaltyHook}: Hook resistant to just-in-time liquidity attacks
  * {AntiSandwichHook}: Hook resistant to sandwich attacks on swaps
  * {LimitOrderHook}: Hook to enable limit order placing on liquidity pools
+ * {ReHypothecationHook}: Hook that enables rehypothecation of liquidity positions.
 
 == Hooks
 
 {{LiquidityPenaltyHook}}
 {{AntiSandwichHook}}
 {{LimitOrderHook}}
+{{ReHypothecationHook}}

src/mocks/ReHypothecationERC4626Mock.sol

@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.26;
+
+// External imports
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import {ERC4626} from "@openzeppelin/contracts/token/ERC20/extensions/ERC4626.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {IERC4626} from "@openzeppelin/contracts/interfaces/IERC4626.sol";
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+
+// Internal imports
+import {ReHypothecationHook} from "../general/ReHypothecationHook.sol";
+
+/// @title ERC4626Mock
+/// @notice A mock implementation of the ERC-4626 yield source.
+contract ERC4626YieldSourceMock is ERC4626 {
+    constructor(IERC20 token) ERC4626(token) ERC20("ERC4626YieldSourceMock", "E4626YS") {}
+}
+
+/// @title ReHypothecationERC4626Mock
+/// @notice A mock implementation of the ReHypothecationHook for ERC-4626 yield sources.
+contract ReHypothecationERC4626Mock is ReHypothecationHook {
+    using SafeERC20 for IERC20;
+
+    /// @dev Error thrown when attempting to use an unsupported currency.
+    error UnsupportedCurrency();
+
+    address private _yieldSource0;
+    address private _yieldSource1;
+
+    constructor(IPoolManager poolManager_, address yieldSource0_, address yieldSource1_)
+        ReHypothecationHook(poolManager_)
+        ERC20("ReHypothecationMock", "RHM")
+    {
+        _yieldSource0 = yieldSource0_;
+        _yieldSource1 = yieldSource1_;
+    }
+
+    /// @dev Override to disable native currency, which is not supported by ERC-4626 yield sources.
+    function _beforeInitialize(address sender, PoolKey calldata key, uint160 sqrtPriceX96)
+        internal
+        override
+        returns (bytes4)
+    {
+        if (key.currency0.isAddressZero()) revert UnsupportedCurrency();
+        return super._beforeInitialize(sender, key, sqrtPriceX96);
+    }
+
+    /// @inheritdoc ReHypothecationHook
+    function getCurrencyYieldSource(Currency currency) public view override returns (address) {
+        PoolKey memory poolKey = getPoolKey();
+        if (currency == poolKey.currency0) return _yieldSource0;
+        if (currency == poolKey.currency1) return _yieldSource1;
+        revert UnsupportedCurrency();
+    }
+
+    /// @inheritdoc ReHypothecationHook
+    function _depositToYieldSource(Currency currency, uint256 amount) internal virtual override {
+        address yieldSource = getCurrencyYieldSource(currency);
+        if (yieldSource == address(0)) revert UnsupportedCurrency();
+        IERC20(Currency.unwrap(currency)).approve(address(yieldSource), amount);
+        IERC4626(yieldSource).deposit(amount, address(this));
+    }
+
+    /// @inheritdoc ReHypothecationHook
+    function _withdrawFromYieldSource(Currency currency, uint256 amount) internal virtual override {
+        IERC4626 yieldSource = IERC4626(getCurrencyYieldSource(currency));
+        if (address(yieldSource) == address(0)) revert UnsupportedCurrency();
+        yieldSource.withdraw(amount, address(this), address(this));
+    }
+
+    /// @inheritdoc ReHypothecationHook
+    function _getAmountInYieldSource(Currency currency) internal view virtual override returns (uint256 amount) {
+        IERC4626 yieldSource = IERC4626(getCurrencyYieldSource(currency));
+        uint256 yieldSourceShares = yieldSource.balanceOf(address(this));
+        return yieldSource.convertToAssets(yieldSourceShares);
+    }
+
+    /// @dev Override to disable native currency, which is not supported by ERC-4626 yield sources.
+    receive() external payable override {
+        revert UnsupportedCurrency();
+    }
+
+    /// @dev Helpers for testing
+    function getAmountInYieldSource(Currency currency) public view returns (uint256) {
+        return _getAmountInYieldSource(currency);
+    }
+
+    // Exclude from coverage report
+    function test() public {}
+}

src/mocks/ReHypothecationNativeMock.sol

@@ -0,0 +1,136 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.26;
+
+// External imports
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
+
+// Internal imports
+import {ReHypothecationHook} from "../general/ReHypothecationHook.sol";
+import {ERC4626YieldSourceMock} from "./ReHypothecationERC4626Mock.sol";
+
+/// @notice A mock implementation of a native yield source.
+/// NOTE: This mock implementation of a native yield source is for testing purposes only.
+contract NativeYieldSourceMock is ERC20 {
+    using Math for *;
+
+    error InvalidAmount();
+
+    constructor() ERC20("NativeYieldSourceMock", "NYSM") {}
+
+    function totalAssets() public view virtual returns (uint256) {
+        return address(this).balance;
+    }
+
+    function convertToAssets(uint256 shares) public view virtual returns (uint256) {
+        return _convertToAssets(shares);
+    }
+
+    function convertToShares(uint256 assets) public view virtual returns (uint256) {
+        return _convertToShares(assets);
+    }
+
+    function _convertToShares(uint256 assets) internal view virtual returns (uint256) {
+        return assets.mulDiv(totalSupply(), totalAssets());
+    }
+
+    function _convertToAssets(uint256 shares) internal view virtual returns (uint256) {
+        return shares.mulDiv(totalAssets(), totalSupply());
+    }
+
+    function deposit(uint256 amount, address to) public payable {
+        if (msg.value != amount) revert InvalidAmount();
+        _mint(to, amount);
+    }
+
+    function withdraw(uint256 assets, address to) public payable {
+        uint256 shares = _convertToShares(assets);
+        _burn(msg.sender, shares);
+        payable(to).transfer(assets);
+    }
+}
+
+/// @title ReHypothecationNativeMock
+/// @notice A mock implementation of the ReHypothecationHook for a mixed use case of native ETH and ERC20 tokens.
+/// The ERC20 is invested into an ERC-4626 yield source, while the native ETH is invested into a native yield source.
+contract ReHypothecationNativeMock is ReHypothecationHook {
+    using SafeERC20 for IERC20;
+
+    address private _yieldSource0;
+    address private _yieldSource1;
+
+    /// @dev Error thrown when attempting to use an unsupported currency.
+    error UnsupportedCurrency();
+
+    constructor(IPoolManager poolManager_, address yieldSource0_, address yieldSource1_)
+        ReHypothecationHook(poolManager_)
+        ERC20("ReHypothecationMock", "RHM")
+    {
+        _yieldSource0 = yieldSource0_;
+        _yieldSource1 = yieldSource1_;
+    }
+
+    /// @inheritdoc ReHypothecationHook
+    function getCurrencyYieldSource(Currency currency) public view override returns (address) {
+        PoolKey memory poolKey = getPoolKey();
+        if (currency == poolKey.currency0) return _yieldSource0;
+        if (currency == poolKey.currency1) return _yieldSource1;
+        revert UnsupportedCurrency();
+    }
+
+    /// @inheritdoc ReHypothecationHook
+    function _depositToYieldSource(Currency currency, uint256 amount) internal virtual override {
+        address yieldSource = getCurrencyYieldSource(currency);
+        if (yieldSource == address(0)) revert UnsupportedCurrency();
+        if (currency.isAddressZero()) {
+            NativeYieldSourceMock(yieldSource).deposit{value: amount}(amount, address(this));
+        } else {
+            IERC20(Currency.unwrap(currency)).approve(address(yieldSource), amount);
+            NativeYieldSourceMock(yieldSource).deposit(amount, address(this));
+        }
+    }
+
+    /// @inheritdoc ReHypothecationHook
+    function _withdrawFromYieldSource(Currency currency, uint256 amount) internal virtual override {
+        address yieldSource = getCurrencyYieldSource(currency);
+        if (address(yieldSource) == address(0)) revert UnsupportedCurrency();
+        if (currency.isAddressZero()) {
+            NativeYieldSourceMock(yieldSource).withdraw(amount, address(this));
+        } else {
+            ERC4626YieldSourceMock(yieldSource).withdraw(amount, address(this), address(this));
+        }
+    }
+
+    /// @inheritdoc ReHypothecationHook
+    function _getAmountInYieldSource(Currency currency) internal view virtual override returns (uint256 amount) {
+        address yieldSource = getCurrencyYieldSource(currency);
+        uint256 yieldSourceShares = IERC20(yieldSource).balanceOf(address(this));
+        return NativeYieldSourceMock(yieldSource).convertToAssets(yieldSourceShares);
+    }
+
+    /// Override required to handle native ETH
+    function _transferFromSenderToHook(Currency currency, uint256 amount, address sender) internal virtual override {
+        if (currency.isAddressZero()) {
+            if (msg.value < amount) revert InvalidMsgValue();
+            if (msg.value > amount) {
+                (bool success,) = msg.sender.call{value: msg.value - amount}("");
+                if (!success) revert RefundFailed();
+            }
+        } else {
+            super._transferFromSenderToHook(currency, amount, sender);
+        }
+    }
+
+    /// @dev Helpers for testing
+    function getAmountInYieldSource(Currency currency) public view returns (uint256) {
+        return _getAmountInYieldSource(currency);
+    }
+
+    // Exclude from coverage report
+    function test() public {}
+}

src/utils/README.adoc

@@ -6,7 +6,9 @@ NOTE: This document is better viewed on the docs page.
 Libraries and general purpose utilities to help develop hooks.
 
  * {CurrencySettler}: Library used to interact with the `PoolManager` to settle any open deltas, with support for ERC-6909 and native currencies.
+ * {LiquidityMath}:  Library with helper functions for liquidity math.
 
 == Libraries
 
 {{CurrencySettler}}
+{{LiquidityMath}}

test/general/LiquidityPenaltyHook.t.sol

@@ -99,7 +99,7 @@ contract LiquidityPenaltyHookTest is HookTest, BalanceDeltaAssertions {
         // since the ataccker is the only LP, himself is the recipient of the whole donation in the hooked pool
         BalanceDelta hookFeeDeltaAfterRemoval =
             calculateFeeDelta(manager, key.toId(), address(modifyLiquidityRouter), -600, 600, bytes32(0));
-        assertAproxEqAbs(hookFeeDeltaAfterRemoval, feeDelta, 1, "Hooked: Attacker received donation");
+        assertApproxEqAbs(hookFeeDeltaAfterRemoval, feeDelta, 1, "Hooked: Attacker received donation");
 
         // in the unhooked pool, the attacker should have collected the fees during liquidity removal
         BalanceDelta noHookFeeDeltaAfterRemoval =
@@ -278,7 +278,7 @@ contract LiquidityPenaltyHookTest is HookTest, BalanceDeltaAssertions {
         BalanceDelta hookDeltaBobRemoval = modifyPoolLiquidity(key, -600, 600, -1e14, bobSalt);
         BalanceDelta noHookDeltaBobRemoval = modifyPoolLiquidity(noHookKey, -600, 600, -1e14, bobSalt);
 
-        assertAproxEqAbs(
+        assertApproxEqAbs(
             hookDeltaBobRemoval,
             noHookDeltaBobRemoval + feeDelta + feeDelta,
             1,