@zoralabs/coins 2.3.0 → 2.3.1

package/test/utils/hookmate/interfaces/router/IUniswapV4Router04.sol

@@ -0,0 +1,173 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.26;
+
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
+import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
+
+import {PathKey} from "./PathKey.sol";
+
+/// @title Uniswap V4 Swap Router
+/// @notice A simple, stateless router for execution of swaps against Uniswap v4 Pools
+/// @dev ABI inspired by UniswapV2Router02; https://github.com/hookmate/v4-router
+interface IUniswapV4Router04 {
+    /// ================ MULTI POOL SWAPS ================= ///
+
+    /// @notice Exact Input Swap; swap the specified amount of input tokens for as many output tokens as possible, along the path
+    /// @param amountIn the amount of input tokens to swap
+    /// @param amountOutMin the minimum amount of output tokens that must be received for the transaction not to revert. reverts on equals to
+    /// @param startCurrency the currency to start the swap from
+    /// @param path the path of v4 Pools to swap through
+    /// @param receiver the address to send the output tokens to
+    /// @param deadline block.timestamp must be before this value, otherwise the transaction will revert
+    /// @return Delta the balance changes from the swap
+    function swapExactTokensForTokens(
+        uint256 amountIn,
+        uint256 amountOutMin,
+        Currency startCurrency,
+        PathKey[] calldata path,
+        address receiver,
+        uint256 deadline
+    ) external payable returns (BalanceDelta);
+
+    /// @notice Exact Output Swap; swap as few input tokens as possible for the specified amount of output tokens, along the path
+    /// @param amountOut the amount of output tokens to receive
+    /// @param amountInMax the maximum amount of input tokens that can be spent for the transaction not to revert. reverts on equal to
+    /// @param startCurrency the currency to start the swap from
+    /// @param path the path of v4 Pools to swap through
+    /// @param receiver the address to send the output tokens to
+    /// @param deadline block.timestamp must be before this value, otherwise the transaction will revert
+    /// @return Delta the balance changes from the swap
+    function swapTokensForExactTokens(
+        uint256 amountOut,
+        uint256 amountInMax,
+        Currency startCurrency,
+        PathKey[] calldata path,
+        address receiver,
+        uint256 deadline
+    ) external payable returns (BalanceDelta);
+
+    /// @notice General-purpose swap interface for Uniswap v4 that handles all types of swaps
+    /// @param amountSpecified the amount of tokens to be swapped, negative for exact input swaps and positive for exact output swaps
+    /// @param amountLimit the minimum amount of output tokens for exact input swaps, the maximum amount of input tokens for exact output swaps
+    /// @param startCurrency the currency to start the swap from
+    /// @param path the path of v4 Pools to swap through
+    /// @param receiver the address to send the output tokens to
+    /// @param deadline block.timestamp must be before this value, otherwise the transaction will revert
+    /// @return Delta the balance changes from the swap
+    function swap(
+        int256 amountSpecified,
+        uint256 amountLimit,
+        Currency startCurrency,
+        PathKey[] calldata path,
+        address receiver,
+        uint256 deadline
+    ) external payable returns (BalanceDelta);
+
+    /// ================ SINGLE POOL SWAPS ================ ///
+
+    /// @notice Single pool, exact input swap - swap the specified amount of input tokens for as many output tokens as possible, on a single pool
+    /// @param amountIn the amount of input tokens to swap
+    /// @param amountOutMin the minimum amount of output tokens that must be received for the transaction not to revert
+    /// @param zeroForOne the direction of the swap, true if currency0 is being swapped for currency1
+    /// @param poolKey the pool to swap through
+    /// @param hookData the data to be passed to the hook
+    /// @param receiver the address to send the output tokens to
+    /// @param deadline block.timestamp must be before this value, otherwise the transaction will revert
+    /// @return Delta the balance changes from the swap
+    function swapExactTokensForTokens(
+        uint256 amountIn,
+        uint256 amountOutMin,
+        bool zeroForOne,
+        PoolKey calldata poolKey,
+        bytes calldata hookData,
+        address receiver,
+        uint256 deadline
+    ) external payable returns (BalanceDelta);
+
+    /// @notice Singe pool, exact output swap; swap as few input tokens as possible for the specified amount of output tokens, on a single pool
+    /// @param amountOut the amount of output tokens to receive
+    /// @param amountInMax the maximum amount of input tokens that can be spent for the transaction not to revert
+    /// @param zeroForOne the direction of the swap, true if currency0 is being swapped for currency1
+    /// @param poolKey the pool to swap through
+    /// @param hookData the data to be passed to the hook
+    /// @param receiver the address to send the output tokens to
+    /// @param deadline block.timestamp must be before this value, otherwise the transaction will revert
+    /// @return Delta the balance changes from the swap
+    function swapTokensForExactTokens(
+        uint256 amountOut,
+        uint256 amountInMax,
+        bool zeroForOne,
+        PoolKey calldata poolKey,
+        bytes calldata hookData,
+        address receiver,
+        uint256 deadline
+    ) external payable returns (BalanceDelta);
+
+    /// @notice General-purpose single-pool swap interface
+    /// @param amountSpecified the amount of tokens to be swapped, negative for exact input swaps and positive for exact output swaps
+    /// @param amountLimit the minimum amount of output tokens for exact input swaps, the maximum amount of input tokens for exact output swaps
+    /// @param zeroForOne the direction of the swap, true if currency0 is being swapped for currency1
+    /// @param poolKey the pool to swap through
+    /// @param hookData the data to be passed to the hook
+    /// @param receiver the address to send the output tokens to
+    /// @param deadline block.timestamp must be before this value, otherwise the transaction will revert
+    /// @return Delta the balance changes from the swap
+    function swap(
+        int256 amountSpecified,
+        uint256 amountLimit,
+        bool zeroForOne,
+        PoolKey calldata poolKey,
+        bytes calldata hookData,
+        address receiver,
+        uint256 deadline
+    ) external payable returns (BalanceDelta);
+
+    /// ================ OPTIMIZED ================ ///
+
+    /// @notice Generic multi-pool swap function that accepts pre-encoded calldata
+    /// @dev Minor optimization to reduce the number of onchain abi.encode calls
+    /// @param data Pre-encoded swap data in one of the following formats:
+    ///     1. For single-pool swaps: abi.encode(
+    ///         BaseData baseData,             // struct containing swap parameters
+    ///         bool zeroForOne,               // direction of swap
+    ///         PoolKey poolKey,               // key of the pool to swap through
+    ///         bytes hookData                 // data to pass to hooks
+    ///     )
+    ///     2. For multi-pool swaps: abi.encode(
+    ///         BaseData baseData,             // struct containing swap parameters
+    ///         Currency startCurrency,        // initial currency in the swap
+    ///         PathKey[] path                 // array of path keys defining the route
+    ///     )
+    ///
+    ///     PERMIT2 EXTENSION:
+    ///     1. For single pool swaps: abi.encode(
+    ///         BaseData baseData,             // struct containing swap parameters
+    ///         bool zeroForOne,               // direction of swap
+    ///         PoolKey poolKey,               // key of the pool to swap through
+    ///         bytes hookData,                // data to pass to hooks
+    ///         PermitPayload permitPayload    // permit2 signature payload
+    ///     )
+    ///     2. For multi-pool swaps: abi.encode(
+    ///         BaseData baseData,             // struct containing swap parameters
+    ///         Currency startCurrency,        // initial currency in the swap
+    ///         PathKey[] path,                // array of path keys defining the route
+    ///         PermitPayload permitPayload    // permit2 signature payload
+    ///     )
+    ///     Where BaseData.flags contains permit2 flag, and PermitPayload contains:
+    ///         - permit: ISignatureTransfer.PermitTransferFrom
+    ///         - signature: bytes
+    ///
+    /// @param deadline block.timestamp must be before this value, otherwise the transaction will revert
+    /// @return Delta the balance changes from the swap
+    function swap(bytes calldata data, uint256 deadline) external payable returns (BalanceDelta);
+
+    /// @notice Provides ETH receipts locked to Pool Manager
+    receive() external payable;
+
+    /// ================ GETTERS ================ ///
+
+    /// @notice Public view function to be used instead of msg.sender, as the contract performs self-reentrancy and at
+    /// times msg.sender == address(this). Instead msgSender() returns the initiator of the lock
+    function msgSender() external view returns (address);
+}

package/test/utils/hookmate/interfaces/router/PathKey.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.26;
+
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
+import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
+
+struct PathKey {
+    Currency intermediateCurrency;
+    uint24 fee;
+    int24 tickSpacing;
+    IHooks hooks;
+    bytes hookData;
+}
+
+using PathKeyLibrary for PathKey global;
+
+/// @title PathKey Library
+/// @notice Memory-oriented version of v4-periphery/src/libraries/PathKeyLibrary.sol
+/// @dev Handles PathKey operations in memory rather than calldata for router operations
+library PathKeyLibrary {
+    /// @notice Get the pool and swap direction for a given PathKey
+    /// @param params the given PathKey
+    /// @param currencyIn the input currency
+    /// @return poolKey the pool key of the swap
+    /// @return zeroForOne the direction of the swap, true if currency0 is being swapped for currency1
+    function getPoolAndSwapDirection(PathKey memory params, Currency currencyIn) internal pure returns (PoolKey memory poolKey, bool zeroForOne) {
+        Currency currencyOut = params.intermediateCurrency;
+        (Currency currency0, Currency currency1) = currencyIn < currencyOut ? (currencyIn, currencyOut) : (currencyOut, currencyIn);
+
+        zeroForOne = currencyIn == currency0;
+        poolKey = PoolKey(currency0, currency1, params.fee, params.tickSpacing, params.hooks);
+    }
+}

package/test/utils/hookmate/test/utils/SwapFeeEventAsserter.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.26;
+
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {Vm} from "forge-std/Vm.sol";
+
+/**
+ * @title Swap Fee Event Asserter
+ * @author saucepoint, akshatmittal
+ */
+library SwapFeeEventAsserter {
+    function getSwapFeeFromEvent(Vm.Log[] memory recordedLogs) internal pure returns (uint24 fee) {
+        for (uint256 i; i < recordedLogs.length; i++) {
+            if (recordedLogs[i].topics[0] == IPoolManager.Swap.selector) {
+                (, , , , , fee) = abi.decode(recordedLogs[i].data, (int128, int128, uint160, uint128, int24, uint24));
+                break;
+            }
+        }
+    }
+
+    function assertSwapFee(Vm vm, Vm.Log[] memory recordedLogs, uint24 expectedFee) internal pure {
+        vm.assertEq(getSwapFeeFromEvent(recordedLogs), expectedFee);
+    }
+}

package/wagmi.config.ts

@@ -14,11 +14,11 @@ export default defineConfig({
         "CreatorCoin",
         "ZoraFactoryImpl",
         "IUniswapV3Pool",
-        "BuySupplyWithSwapRouterHook",
         "IPoolConfigEncoding",
         "IUniversalRouter",
         "IPermit2",
         "AutoSwapper",
+        "BuySupplyWithV4SwapHook",
       ].map((contractName) => `${contractName}.json`),
     }),
   ],

package/src/utils/uniswap/BytesLib.sol

@@ -1,35 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-/*
- * @title Solidity Bytes Arrays Utils
- * @author Gonçalo Sá <goncalo.sa@consensys.net>
- *
- * @dev Bytes tightly packed arrays utility library for ethereum contracts written in Solidity.
- *      The library lets you concatenate, slice and type cast bytes arrays both in memory and storage.
- */
-pragma solidity ^0.8.28;
-
-library BytesLib {
-    function toAddress(bytes memory _bytes, uint256 _start) internal pure returns (address) {
-        require(_start + 20 >= _start, "toAddress_overflow");
-        require(_bytes.length >= _start + 20, "toAddress_outOfBounds");
-        address tempAddress;
-
-        assembly {
-            tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)
-        }
-
-        return tempAddress;
-    }
-
-    function toUint24(bytes memory _bytes, uint256 _start) internal pure returns (uint24) {
-        require(_start + 3 >= _start, "toUint24_overflow");
-        require(_bytes.length >= _start + 3, "toUint24_outOfBounds");
-        uint24 tempUint;
-
-        assembly {
-            tempUint := mload(add(add(_bytes, 0x3), _start))
-        }
-
-        return tempUint;
-    }
-}

package/src/utils/uniswap/Path.sol

@@ -1,31 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-pragma solidity ^0.8.28;
-
-import "./BytesLib.sol";
-
-// copied from https://github.com/Uniswap/v3-periphery/blob/main/contracts/libraries/Path.sol
-// with certain functionality removed
-
-/// @title Functions for manipulating path data for multihop swaps
-library Path {
-    using BytesLib for bytes;
-
-    /// @dev The length of the bytes encoded address
-    uint256 private constant ADDR_SIZE = 20;
-    /// @dev The length of the bytes encoded fee
-    uint256 private constant FEE_SIZE = 3;
-
-    /// @dev The offset of a single token address and pool fee
-    uint256 private constant NEXT_OFFSET = ADDR_SIZE + FEE_SIZE;
-
-    /// @notice Decodes the first pool in path
-    /// @param path The bytes encoded swap path
-    /// @return tokenA The first token of the given pool
-    /// @return tokenB The second token of the given pool
-    /// @return fee The fee level of the pool
-    function decodeFirstPool(bytes memory path) internal pure returns (address tokenA, address tokenB, uint24 fee) {
-        tokenA = path.toAddress(0);
-        fee = path.toUint24(ADDR_SIZE);
-        tokenB = path.toAddress(NEXT_OFFSET);
-    }
-}