@zoralabs/coins 0.9.0 → 1.0.0

package/src/libs/UniV3BuySell.sol

@@ -13,21 +13,15 @@ import {LpPosition} from "../types/LpPosition.sol";
 import {PoolConfiguration} from "../interfaces/ICoin.sol";
 import {IUniswapV3Pool} from "../interfaces/IUniswapV3Pool.sol";
 import {IAirlock} from "../interfaces/IAirlock.sol";
-import {UniV3Config, CoinV3Config} from "./CoinSetupV3.sol";
+import {CoinV3Config} from "./CoinSetupV3.sol";
 import {Address} from "@openzeppelin/contracts/utils/Address.sol";
-import {CoinLegacyMarket} from "./CoinLegacyMarket.sol";
 import {CoinDopplerUniV3} from "./CoinDopplerUniV3.sol";
 import {CoinConfigurationVersions} from "./CoinConfigurationVersions.sol";
-
-struct CoinConfig {
-    address protocolRewardRecipient;
-    address platformReferrer;
-    address currency;
-    address payoutRecipient;
-    address protocolRewards;
-    address poolAddress;
-    PoolConfiguration poolConfiguration;
-    UniV3Config uniswapV3Config;
+import {CoinRewards, CoinConfig} from "./CoinRewards.sol";
+struct SellResult {
+    uint256 payoutSize;
+    uint256 tradeReward;
+    uint256 trueOrderSize;
 }
 
 library UniV3BuySell {
@@ -36,14 +30,16 @@ library UniV3BuySell {
     error AddressZero();
     error InvalidPoolVersion();
 
-    function _handleBuy(
+    function handleBuy(
         address recipient,
         uint256 orderSize,
         uint256 minAmountOut,
         uint160 sqrtPriceLimitX96,
         address tradeReferrer,
-        address coin,
-        CoinConfig memory coinConfig
+        CoinConfig memory coinConfig,
+        address currency,
+        ISwapRouter swapRouter,
+        IWETH weth
     ) internal returns (uint256 amountOut, uint256 tradeReward, uint256 trueOrderSize) {
         if (recipient == address(0)) {
             revert AddressZero();
@@ -56,12 +52,12 @@ library UniV3BuySell {
         trueOrderSize = orderSize - tradeReward;
 
         // Handle incoming currency
-        _handleIncomingCurrency(orderSize, trueOrderSize, coinConfig.currency, coinConfig.uniswapV3Config.weth, coinConfig.uniswapV3Config.swapRouter);
+        _handleIncomingCurrency(orderSize, trueOrderSize, currency, swapRouter, weth);
 
         // Set up the swap parameters
         ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({
-            tokenIn: coinConfig.currency,
-            tokenOut: coin,
+            tokenIn: currency,
+            tokenOut: address(this),
             fee: MarketConstants.LP_FEE,
             recipient: recipient,
             amountIn: trueOrderSize,
@@ -70,60 +66,21 @@ library UniV3BuySell {
         });
 
         // Execute the swap
-        amountOut = ISwapRouter(coinConfig.uniswapV3Config.swapRouter).exactInputSingle(params);
+        amountOut = ISwapRouter(swapRouter).exactInputSingle(params);
 
-        _handleTradeRewards(tradeReward, tradeReferrer, coinConfig);
+        CoinRewards.handleTradeRewards(tradeReward, tradeReferrer, coinConfig, currency, weth);
     }
 
-    /// @notice Executes a buy order
-    /// @param recipient The recipient address of the coins
-    /// @param orderSize The amount of coins to buy
-    /// @param tradeReferrer The address of the trade referrer
-    /// @param sqrtPriceLimitX96 The price limit for Uniswap V3 pool swap
-    function buy(
-        address recipient,
+    function _executeSwap(
         uint256 orderSize,
         uint256 minAmountOut,
         uint160 sqrtPriceLimitX96,
-        address tradeReferrer,
-        address coin,
-        CoinConfig memory coinConfig
-    ) internal returns (uint256, uint256) {
-        (uint256 amountOut, uint256 tradeReward, uint256 trueOrderSize) = _handleBuy(
-            recipient,
-            orderSize,
-            minAmountOut,
-            sqrtPriceLimitX96,
-            tradeReferrer,
-            coin,
-            coinConfig
-        );
-
-        handleMarketRewards(coin, coinConfig);
-
-        emit ICoin.CoinBuy(msg.sender, recipient, tradeReferrer, amountOut, coinConfig.currency, tradeReward, trueOrderSize);
-
-        return (orderSize, amountOut);
-    }
-
-    function _handleSell(
-        address recipient,
-        uint256 beforeCoinBalance,
-        uint256 orderSize,
-        uint256 minAmountOut,
-        uint160 sqrtPriceLimitX96,
-        address tradeReferrer,
-        CoinConfig memory coinConfig
-    ) internal returns (uint256 payoutSize, uint256 tradeReward, uint256 trueOrderSize) {
-        // Ensure the recipient is not the zero address
-        if (recipient == address(0)) {
-            revert AddressZero();
-        }
-
-        // Set the swap parameters
+        address currency,
+        ISwapRouter swapRouter
+    ) internal returns (uint256 amountOut) {
         ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({
             tokenIn: address(this),
-            tokenOut: coinConfig.currency,
+            tokenOut: currency,
             fee: MarketConstants.LP_FEE,
             recipient: address(this),
             amountIn: orderSize,
@@ -131,78 +88,66 @@ library UniV3BuySell {
             sqrtPriceLimitX96: sqrtPriceLimitX96
         });
 
-        // Execute the swap
-        uint256 amountOut = ISwapRouter(coinConfig.uniswapV3Config.swapRouter).exactInputSingle(params);
+        amountOut = swapRouter.exactInputSingle(params);
+    }
 
-        // Record the coin balance of this contract after the swap
+    function _handleRefund(uint256 beforeCoinBalance, uint256 orderSize, address recipient) internal returns (uint256 trueOrderSize) {
         uint256 afterCoinBalance = IERC20(address(this)).balanceOf(address(this));
-
         trueOrderSize = orderSize;
 
-        // If the swap was partially executed:
         if (afterCoinBalance > beforeCoinBalance) {
-            // Calculate the refund
             uint256 coinRefund = afterCoinBalance - beforeCoinBalance;
-
-            // Update the order size
             trueOrderSize -= coinRefund;
-
-            // Transfer the refund back to the seller
             IERC20(address(this)).safeTransfer(recipient, coinRefund);
         }
+    }
 
-        // If currency is WETH, convert to ETH
-        if (coinConfig.currency == coinConfig.uniswapV3Config.weth) {
-            IWETH(coinConfig.uniswapV3Config.weth).withdraw(amountOut);
+    function _handlePayoutAndRewards(
+        uint256 amountOut,
+        address recipient,
+        address tradeReferrer,
+        CoinConfig memory coinConfig,
+        address currency,
+        IWETH weth
+    ) internal returns (uint256 payoutSize, uint256 tradeReward) {
+        if (currency == address(weth)) {
+            weth.withdraw(amountOut);
         }
 
-        // Calculate the trade reward
         tradeReward = _calculateReward(amountOut, CoinConstants.TOTAL_FEE_BPS);
-
-        // Calculate the payout after the fee
         payoutSize = amountOut - tradeReward;
 
-        _handlePayout(payoutSize, recipient, coinConfig.currency, coinConfig.uniswapV3Config.weth);
+        _handlePayout(payoutSize, recipient, currency, weth);
 
-        _handleTradeRewards(tradeReward, tradeReferrer, coinConfig);
+        CoinRewards.handleTradeRewards(tradeReward, tradeReferrer, coinConfig, currency, weth);
     }
 
-    /// @notice Executes a sell order
-    /// @param recipient The recipient of the currency
-    /// @param _orderSize The amount of coins to sell
-    /// @param minAmountOut The minimum amount of currency to receive
-    /// @param sqrtPriceLimitX96 The price limit for the swap
-    /// @param tradeReferrer The address of the trade referrer
-    function sell(
+    function handleSell(
         address recipient,
         uint256 beforeCoinBalance,
-        uint256 _orderSize,
+        uint256 orderSize,
         uint256 minAmountOut,
         uint160 sqrtPriceLimitX96,
         address tradeReferrer,
-        CoinConfig memory coinConfig
-    ) internal returns (uint256 trueOrderSize, uint256 payoutSize) {
-        uint256 tradeReward;
-        (payoutSize, tradeReward, trueOrderSize) = _handleSell(
-            recipient,
-            beforeCoinBalance,
-            _orderSize,
-            minAmountOut,
-            sqrtPriceLimitX96,
-            tradeReferrer,
-            coinConfig
-        );
-
-        handleMarketRewards(address(this), coinConfig);
-
-        emit ICoin.CoinSell(msg.sender, recipient, tradeReferrer, trueOrderSize, coinConfig.currency, tradeReward, payoutSize);
+        CoinConfig memory coinConfig,
+        address currency,
+        ISwapRouter swapRouter,
+        IWETH weth
+    ) internal returns (SellResult memory result) {
+        if (recipient == address(0)) {
+            revert AddressZero();
+        }
+
+        uint256 amountOut = _executeSwap(orderSize, minAmountOut, sqrtPriceLimitX96, currency, swapRouter);
+        result.trueOrderSize = _handleRefund(beforeCoinBalance, orderSize, recipient);
+        (result.payoutSize, result.tradeReward) = _handlePayoutAndRewards(amountOut, recipient, tradeReferrer, coinConfig, currency, weth);
     }
 
     /// @dev Handles incoming currency transfers for buy orders; if WETH is the currency the caller has the option to send native-ETH
     /// @param orderSize The total size of the order in the currency
     /// @param trueOrderSize The actual amount being used for the swap after fees
-    function _handleIncomingCurrency(uint256 orderSize, uint256 trueOrderSize, address currency, address weth, address swapRouter) internal {
-        if (currency == weth && msg.value > 0) {
+    function _handleIncomingCurrency(uint256 orderSize, uint256 trueOrderSize, address currency, ISwapRouter swapRouter, IWETH weth) internal {
+        if (currency == address(weth) && msg.value > 0) {
             if (msg.value != orderSize) {
                 revert ICoin.EthAmountMismatch();
             }
@@ -212,7 +157,7 @@ library UniV3BuySell {
             }
 
             IWETH(weth).deposit{value: trueOrderSize}();
-            IWETH(weth).approve(swapRouter, trueOrderSize);
+            IWETH(weth).approve(address(swapRouter), trueOrderSize);
         } else {
             // Ensure ETH is not sent with a non-ETH pair
             if (msg.value != 0) {
@@ -227,100 +172,27 @@ library UniV3BuySell {
                 revert ICoin.ERC20TransferAmountMismatch();
             }
 
-            IERC20(currency).approve(swapRouter, trueOrderSize);
+            IERC20(currency).approve(address(swapRouter), trueOrderSize);
         }
     }
 
     /// @dev Handles sending ETH and ERC20 payouts and refunds to recipients
     /// @param orderPayout The amount of currency to pay out
     /// @param recipient The address to receive the payout
-    function _handlePayout(uint256 orderPayout, address recipient, address currency, address weth) internal {
-        if (currency == weth) {
+    function _handlePayout(uint256 orderPayout, address recipient, address currency, IWETH weth) internal {
+        if (currency == address(weth)) {
             Address.sendValue(payable(recipient), orderPayout);
         } else {
             IERC20(currency).safeTransfer(recipient, orderPayout);
         }
     }
 
-    /// @dev Handles calculating and depositing fees to an escrow protocol rewards contract
-    function _handleTradeRewards(uint256 totalValue, address _tradeReferrer, CoinConfig memory coinConfig) internal {
-        address protocolRewardRecipient = coinConfig.protocolRewardRecipient;
-        address platformReferrer = coinConfig.platformReferrer;
-        address currency = coinConfig.currency;
-        address weth = coinConfig.uniswapV3Config.weth;
-        address payoutRecipient = coinConfig.payoutRecipient;
-        IProtocolRewards protocolRewards = IProtocolRewards(coinConfig.protocolRewards);
-
-        if (_tradeReferrer == address(0)) {
-            _tradeReferrer = protocolRewardRecipient;
-        }
-
-        uint256 tokenCreatorFee = _calculateReward(totalValue, CoinConstants.TOKEN_CREATOR_FEE_BPS);
-        uint256 platformReferrerFee = _calculateReward(totalValue, CoinConstants.PLATFORM_REFERRER_FEE_BPS);
-        uint256 tradeReferrerFee = _calculateReward(totalValue, CoinConstants.TRADE_REFERRER_FEE_BPS);
-        uint256 protocolFee = totalValue - tokenCreatorFee - platformReferrerFee - tradeReferrerFee;
-
-        if (currency == weth) {
-            address[] memory recipients = new address[](4);
-            uint256[] memory amounts = new uint256[](4);
-            bytes4[] memory reasons = new bytes4[](4);
-
-            recipients[0] = payoutRecipient;
-            amounts[0] = tokenCreatorFee;
-            reasons[0] = bytes4(keccak256("COIN_CREATOR_REWARD"));
-
-            recipients[1] = platformReferrer;
-            amounts[1] = platformReferrerFee;
-            reasons[1] = bytes4(keccak256("COIN_PLATFORM_REFERRER_REWARD"));
-
-            recipients[2] = _tradeReferrer;
-            amounts[2] = tradeReferrerFee;
-            reasons[2] = bytes4(keccak256("COIN_TRADE_REFERRER_REWARD"));
-
-            recipients[3] = protocolRewardRecipient;
-            amounts[3] = protocolFee;
-            reasons[3] = bytes4(keccak256("COIN_PROTOCOL_REWARD"));
-
-            IProtocolRewards(protocolRewards).depositBatch{value: totalValue}(recipients, amounts, reasons, "");
-        }
-
-        if (currency != weth) {
-            IERC20(currency).safeTransfer(payoutRecipient, tokenCreatorFee);
-            IERC20(currency).safeTransfer(platformReferrer, platformReferrerFee);
-            IERC20(currency).safeTransfer(_tradeReferrer, tradeReferrerFee);
-            IERC20(currency).safeTransfer(protocolRewardRecipient, protocolFee);
-        }
-
-        emit ICoin.CoinTradeRewards(
-            payoutRecipient,
-            platformReferrer,
-            _tradeReferrer,
-            protocolRewardRecipient,
-            tokenCreatorFee,
-            platformReferrerFee,
-            tradeReferrerFee,
-            protocolFee,
-            currency
-        );
-    }
-
-    function _distributeMarketRewards(
-        LpPosition[] memory positions,
-        address poolAddress,
-        address currency,
-        address coin,
-        CoinConfig memory coinConfig
-    ) internal returns (ICoin.MarketRewards memory) {
-        uint256 totalAmountToken0;
-        uint256 totalAmountToken1;
-        uint256 amount0;
-        uint256 amount1;
-
+    function _collectFees(LpPosition[] storage positions, address poolAddress) internal returns (uint256 totalAmountToken0, uint256 totalAmountToken1) {
         for (uint256 i; i < positions.length; i++) {
             // Must burn to update the collect mapping on the pool
             IUniswapV3Pool(poolAddress).burn(positions[i].tickLower, positions[i].tickUpper, 0);
 
-            (amount0, amount1) = IUniswapV3Pool(poolAddress).collect(
+            (uint256 amount0, uint256 amount1) = IUniswapV3Pool(poolAddress).collect(
                 address(this),
                 positions[i].tickLower,
                 positions[i].tickUpper,
@@ -331,119 +203,29 @@ library UniV3BuySell {
             totalAmountToken0 += amount0;
             totalAmountToken1 += amount1;
         }
-
-        address token0 = currency < address(this) ? currency : address(this);
-        address token1 = currency < address(this) ? address(this) : currency;
-
-        ICoin.MarketRewards memory rewards;
-
-        rewards = _transferMarketRewards(token0, totalAmountToken0, rewards, coin, coinConfig);
-        rewards = _transferMarketRewards(token1, totalAmountToken1, rewards, coin, coinConfig);
-
-        emit ICoin.CoinMarketRewards(coinConfig.payoutRecipient, coinConfig.platformReferrer, coinConfig.protocolRewardRecipient, coinConfig.currency, rewards);
-
-        return rewards;
     }
 
     /// @dev Collects and distributes accrued fees from all LP positions
-    function handleMarketRewards(address coin, CoinConfig memory coinConfig) internal returns (ICoin.MarketRewards memory) {
-        address poolAddress = coinConfig.poolAddress;
-        address currency = coinConfig.currency;
-
-        bool isCoinToken0 = coin < currency;
-        LpPosition[] memory positions = calculatePositions(isCoinToken0, coinConfig.poolConfiguration);
+    function handleMarketRewards(
+        CoinConfig memory coinConfig,
+        address currency,
+        address poolAddress,
+        LpPosition[] storage positions,
+        IWETH weth,
+        address doppler
+    ) internal returns (ICoin.MarketRewards memory rewards) {
+        address coin = address(this);
+        (uint256 totalAmountToken0, uint256 totalAmountToken1) = _collectFees(positions, poolAddress);
 
-        return _distributeMarketRewards(positions, poolAddress, currency, coin, coinConfig);
-    }
+        address token0 = currency < coin ? currency : coin;
+        address token1 = currency < coin ? coin : currency;
 
-    function _transferMarketRewards(
-        address token,
-        uint256 totalAmount,
-        ICoin.MarketRewards memory rewards,
-        address coin,
-        CoinConfig memory coinConfig
-    ) internal returns (ICoin.MarketRewards memory) {
-        address payoutRecipient = coinConfig.payoutRecipient;
-        address platformReferrer = coinConfig.platformReferrer;
-        address protocolRewardRecipient = coinConfig.protocolRewardRecipient;
-        address currency = coinConfig.currency;
-        address weth = coinConfig.uniswapV3Config.weth;
-        address airlock = coinConfig.uniswapV3Config.airlock;
-        address protocolRewards = coinConfig.protocolRewards;
-
-        if (totalAmount > 0) {
-            address dopplerRecipient = IAirlock(airlock).owner();
-            uint256 dopplerPayout = _calculateReward(totalAmount, CoinConstants.DOPPLER_MARKET_REWARD_BPS);
-            uint256 creatorPayout = _calculateReward(totalAmount, CoinConstants.CREATOR_MARKET_REWARD_BPS);
-            uint256 platformReferrerPayout = _calculateReward(totalAmount, CoinConstants.PLATFORM_REFERRER_MARKET_REWARD_BPS);
-            uint256 protocolPayout = totalAmount - creatorPayout - platformReferrerPayout - dopplerPayout;
-
-            if (token == weth) {
-                IWETH(weth).withdraw(totalAmount);
-
-                rewards.totalAmountCurrency = totalAmount;
-                rewards.creatorPayoutAmountCurrency = creatorPayout;
-                rewards.platformReferrerAmountCurrency = platformReferrerPayout;
-                rewards.protocolAmountCurrency = protocolPayout;
-
-                address[] memory recipients = new address[](4);
-                recipients[0] = payoutRecipient;
-                recipients[1] = platformReferrer;
-                recipients[2] = protocolRewardRecipient;
-                recipients[3] = dopplerRecipient;
-
-                uint256[] memory amounts = new uint256[](4);
-                amounts[0] = rewards.creatorPayoutAmountCurrency;
-                amounts[1] = rewards.platformReferrerAmountCurrency;
-                amounts[2] = rewards.protocolAmountCurrency;
-                amounts[3] = dopplerPayout;
-
-                bytes4[] memory reasons = new bytes4[](4);
-                reasons[0] = bytes4(keccak256("COIN_CREATOR_MARKET_REWARD"));
-                reasons[1] = bytes4(keccak256("COIN_PLATFORM_REFERRER_MARKET_REWARD"));
-                reasons[2] = bytes4(keccak256("COIN_PROTOCOL_MARKET_REWARD"));
-                reasons[3] = bytes4(keccak256("COIN_DOPPLER_MARKET_REWARD"));
-
-                IProtocolRewards(protocolRewards).depositBatch{value: totalAmount}(recipients, amounts, reasons, "");
-                IProtocolRewards(protocolRewards).withdrawFor(dopplerRecipient, dopplerPayout);
-            } else if (token == coin) {
-                rewards.totalAmountCoin = totalAmount;
-                rewards.creatorPayoutAmountCoin = creatorPayout;
-                rewards.platformReferrerAmountCoin = platformReferrerPayout;
-                rewards.protocolAmountCoin = protocolPayout;
-
-                IERC20(coin).safeTransfer(payoutRecipient, rewards.creatorPayoutAmountCoin);
-                IERC20(coin).safeTransfer(platformReferrer, rewards.platformReferrerAmountCoin);
-                IERC20(coin).safeTransfer(protocolRewardRecipient, rewards.protocolAmountCoin);
-                IERC20(coin).safeTransfer(dopplerRecipient, dopplerPayout);
-            } else {
-                rewards.totalAmountCurrency = totalAmount;
-                rewards.creatorPayoutAmountCurrency = creatorPayout;
-                rewards.platformReferrerAmountCurrency = platformReferrerPayout;
-                rewards.protocolAmountCurrency = protocolPayout;
-
-                IERC20(currency).safeTransfer(payoutRecipient, creatorPayout);
-                IERC20(currency).safeTransfer(platformReferrer, platformReferrerPayout);
-                IERC20(currency).safeTransfer(protocolRewardRecipient, protocolPayout);
-                IERC20(currency).safeTransfer(dopplerRecipient, dopplerPayout);
-            }
-        }
+        rewards = CoinRewards.transferBothRewards(token0, totalAmountToken0, token1, totalAmountToken1, coin, coinConfig, currency, weth, doppler);
 
-        return rewards;
+        emit ICoin.CoinMarketRewards(coinConfig.payoutRecipient, coinConfig.platformReferrer, coinConfig.protocolRewardRecipient, currency, rewards);
     }
 
-    /// @dev Utility for computing amounts in basis points.
     function _calculateReward(uint256 amount, uint256 bps) internal pure returns (uint256) {
-        return (amount * bps) / 10_000;
-    }
-
-    function calculatePositions(bool isCoinToken0, PoolConfiguration memory poolConfiguration) internal pure returns (LpPosition[] memory positions) {
-        if (poolConfiguration.version == CoinConfigurationVersions.LEGACY_POOL_VERSION) {
-            positions = CoinLegacyMarket.calculatePositions(isCoinToken0, poolConfiguration);
-        } else if (poolConfiguration.version == CoinConfigurationVersions.DOPPLER_UNI_V3_POOL_VERSION) {
-            positions = CoinDopplerUniV3.calculatePositions(isCoinToken0, poolConfiguration);
-        } else {
-            revert InvalidPoolVersion();
-        }
+        return CoinRewards.calculateReward(amount, bps);
     }
 }

package/src/libs/UniV4SwapHelper.sol

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {Commands} from "@uniswap/universal-router/contracts/libraries/Commands.sol";
+import {Actions} from "@uniswap/v4-periphery/src/libraries/Actions.sol";
+import {IV4Router} from "@uniswap/v4-periphery/src/interfaces/IV4Router.sol";
+import {CoinCommon} from "./CoinCommon.sol";
+import {IPermit2} from "permit2/src/interfaces/IPermit2.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
+import {ISwapPathRouter} from "../interfaces/ISwapPathRouter.sol";
+import {IHasPoolKey} from "../interfaces/ICoinV4.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {PathKey} from "@uniswap/v4-periphery/src/libraries/PathKey.sol";
+
+library UniV4SwapHelper {
+    function buildExactInputSingleSwapCommand(
+        address currencyIn,
+        uint128 amountIn,
+        address currencyOut,
+        uint128 minAmountOut,
+        PoolKey memory key,
+        bytes memory hookData
+    ) internal pure returns (bytes memory commands, bytes[] memory inputs) {
+        bool zeroForOne = Currency.unwrap(key.currency0) == currencyIn;
+
+        // now buy some coin for usdc
+        commands = abi.encodePacked(uint8(Commands.V4_SWAP));
+
+        bytes memory actions = abi.encodePacked(uint8(Actions.SWAP_EXACT_IN_SINGLE), uint8(Actions.SETTLE_ALL), uint8(Actions.TAKE_ALL));
+
+        bytes[] memory params = new bytes[](3);
+
+        // First parameter: swap configuration
+        params[0] = abi.encode(
+            IV4Router.ExactInputSingleParams({
+                poolKey: key,
+                zeroForOne: zeroForOne,
+                amountIn: amountIn, // amount of tokens we're swapping
+                amountOutMinimum: minAmountOut, // minimum amount we expect to receive
+                hookData: hookData
+            })
+        );
+
+        // Second parameter: specify input tokens for the swap
+        // encode SETTLE_ALL parameters
+        params[1] = abi.encode(currencyIn, amountIn);
+
+        // Third parameter: specify output tokens from the swap
+        // encode TAKE_ALL parameters
+        params[2] = abi.encode(currencyOut, minAmountOut);
+
+        inputs = new bytes[](1);
+
+        // Combine actions and params into inputs
+        inputs[0] = abi.encode(actions, params);
+    }
+
+    function approveTokenWithPermit2(IPermit2 permit2, address router, address token, uint160 amount, uint48 expiration) internal {
+        IERC20(token).approve(address(permit2), type(uint256).max);
+        permit2.approve(token, router, amount, expiration);
+    }
+}

package/src/libs/UniV4SwapToCurrency.sol

@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
+import {ISwapPathRouter} from "../interfaces/ISwapPathRouter.sol";
+import {IHasPoolKey} from "../interfaces/ICoinV4.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {IPoolManager, PoolKey} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {SwapParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
+import {BalanceDelta, BalanceDeltaLibrary} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
+import {IHasSwapPath} from "../interfaces/ICoinV4.sol";
+import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
+import {PathKey} from "@uniswap/v4-periphery/src/libraries/PathKey.sol";
+import {IDeployedCoinVersionLookup} from "../interfaces/IDeployedCoinVersionLookup.sol";
+import {IZoraV4CoinHook} from "../interfaces/IZoraV4CoinHook.sol";
+import {CoinConfigurationVersions} from "./CoinConfigurationVersions.sol";
+
+library UniV4SwapToCurrency {
+    using BalanceDeltaLibrary for BalanceDelta;
+
+    function swapToPath(
+        IPoolManager poolManager,
+        uint128 amount0,
+        uint128 amount1,
+        Currency currencyIn,
+        PathKey[] memory path
+    ) internal returns (Currency lastCurrency, uint128 lastCurrencyBalance) {
+        require(path.length > 0, IZoraV4CoinHook.PathMustHaveAtLeastOneStep());
+
+        // do first swap - the first swap updates output the balance with the initial balance that existed before the swap
+        (lastCurrency, lastCurrencyBalance) = _doFirstSwapFromCoinToCurrency(poolManager, path[0], currencyIn, amount0, amount1);
+
+        // for each path, swap the currency to the next currency
+        for (uint256 i = 1; i < path.length; i++) {
+            (PoolKey memory poolKey, bool zeroForOne) = _getPoolAndSwapDirection(path[i], lastCurrency);
+            lastCurrencyBalance = uint128(_swap(poolManager, poolKey, zeroForOne, -int128(lastCurrencyBalance), ""));
+            lastCurrency = zeroForOne ? poolKey.currency1 : poolKey.currency0;
+        }
+    }
+
+    function _doFirstSwapFromCoinToCurrency(
+        IPoolManager poolManager,
+        PathKey memory pathKey,
+        Currency coin,
+        uint128 amount0,
+        uint128 amount1
+    ) private returns (Currency outputCurrency, uint128 outputAmount) {
+        (PoolKey memory poolKey, bool zeroForOne) = _getPoolAndSwapDirection(pathKey, coin);
+
+        uint128 coinAmount = zeroForOne ? amount0 : amount1;
+
+        outputCurrency = zeroForOne ? poolKey.currency1 : poolKey.currency0;
+
+        uint128 initialAmountCurrency = zeroForOne ? amount1 : amount0;
+
+        // if not swapping any coin for currency, output amount is amount of currency
+        if (coinAmount == 0) {
+            outputAmount = initialAmountCurrency;
+        } else {
+            outputAmount = uint128(_swap(poolManager, poolKey, zeroForOne, -int128(coinAmount), bytes("")));
+        }
+    }
+
+    function _swap(
+        IPoolManager poolManager,
+        PoolKey memory poolKey,
+        bool zeroForOne,
+        int256 amountSpecified,
+        bytes memory hookData
+    ) private returns (int128 reciprocalAmount) {
+        // for protection of exactOut swaps, sqrtPriceLimit is not exposed as a feature in this contract
+        unchecked {
+            BalanceDelta delta = poolManager.swap(
+                poolKey,
+                SwapParams(zeroForOne, amountSpecified, zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1),
+                hookData
+            );
+
+            reciprocalAmount = (zeroForOne == amountSpecified < 0) ? delta.amount1() : delta.amount0();
+        }
+    }
+
+    /// @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);
+    }
+
+    function getSubSwapPath(address currency, IDeployedCoinVersionLookup coinVersionLookup) internal view returns (PathKey[] memory) {
+        if (!_hasSwapPath(currency, coinVersionLookup)) {
+            return new PathKey[](0);
+        }
+        return IHasSwapPath(currency).getPayoutSwapPath(coinVersionLookup).path;
+    }
+
+    function _hasSwapPath(address currency, IDeployedCoinVersionLookup coinVersionLookup) private view returns (bool) {
+        if (CoinConfigurationVersions.isV4(coinVersionLookup.getVersionForDeployedCoin(currency))) {
+            return IERC165(currency).supportsInterface(type(IHasSwapPath).interfaceId);
+        }
+        return false;
+    }
+}