@zoralabs/coins 0.7.1 → 1.0.0

package/src/libs/CoinSetupV3.sol

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {PoolConfiguration} from "../interfaces/ICoin.sol";
+import {CoinDopplerUniV3} from "./CoinDopplerUniV3.sol";
+import {CoinConfigurationVersions} from "./CoinConfigurationVersions.sol";
+import {LpPosition} from "../types/LpPosition.sol";
+import {IUniswapV3Factory} from "../interfaces/IUniswapV3Factory.sol";
+import {MarketConstants} from "./MarketConstants.sol";
+import {IUniswapV3Pool} from "../interfaces/IUniswapV3Pool.sol";
+import {ICoin} from "../interfaces/ICoin.sol";
+import {CoinCommon} from "./CoinCommon.sol";
+struct UniV3Config {
+    address weth;
+    address v3Factory;
+    address airlock;
+    address swapRouter;
+}
+
+struct CoinV3Config {
+    address currency;
+    PoolConfiguration poolConfiguration;
+    address poolAddress;
+}
+
+library CoinSetupV3 {
+    /// @dev Deploys the Uniswap V3 pool and mints initial liquidity based on the pool configuration
+    function deployLiquidity(LpPosition[] memory positions, address poolAddress) internal {
+        // Calculate and mint positions
+        _mintPositions(positions, poolAddress);
+    }
+
+    /// @dev Mints the calculated liquidity positions into the Uniswap V3 pool
+    function _mintPositions(LpPosition[] memory lbpPositions, address poolAddress) internal {
+        for (uint256 i; i < lbpPositions.length; i++) {
+            IUniswapV3Pool(poolAddress).mint(address(this), lbpPositions[i].tickLower, lbpPositions[i].tickUpper, lbpPositions[i].liquidity, "");
+        }
+    }
+
+    /// @dev Creates the Uniswap V3 pool for the coin/currency pair
+    function createV3Pool(address coin, address currency, bool isCoinToken0, uint160 sqrtPriceX96, address v3Factory) internal returns (address pool) {
+        address token0 = isCoinToken0 ? coin : currency;
+        address token1 = isCoinToken0 ? currency : coin;
+        pool = IUniswapV3Factory(v3Factory).createPool(token0, token1, MarketConstants.LP_FEE);
+
+        // This pool should be new, if it has already been initialized
+        // then we will fail the creation step prompting the user to try again.
+        IUniswapV3Pool(pool).initialize(sqrtPriceX96);
+    }
+}

package/src/libs/DopplerMath.sol

@@ -0,0 +1,156 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.24;
+
+import {IDopplerErrors} from "../interfaces/IDopplerErrors.sol";
+import {TickMath} from "../utils/uniswap/TickMath.sol";
+import {FullMath} from "../utils/uniswap/FullMath.sol";
+import {SqrtPriceMath} from "../utils/uniswap/SqrtPriceMath.sol";
+import {LiquidityAmounts} from "../utils/uniswap/LiquidityAmounts.sol";
+import {LpPosition} from "../types/LpPosition.sol";
+import {MarketConstants} from "./MarketConstants.sol";
+
+/// @author Whetstone Research
+/// @notice Calculates liquidity provisioning with Uniswap v3
+library DopplerMath {
+    /// @notice Calculates the distribution of liquidity positions across tick ranges.
+    /// @dev For example, with 1000 tokens and 10 bins starting at tick 0:
+    ///      - Creates positions: [0,10], [1,10], [2,10], ..., [9,10]
+    ///      - Each position gets an equal share of tokens (100 tokens each)
+    ///      This creates a linear distribution of liquidity across the tick range
+    /// @dev Changed from UniswapV3Initializer:
+    ///      - Added `LpPosition[] memory newPositions` as an input parameter, removing the internal allocation (`new LpPosition[](totalPositions + 1)`).
+    ///      - Added `uint256 positionOffset` as an input parameter to specify the starting write index within the `newPositions` array.
+    ///      - Removed the calculation and accumulation of the `reserves` variable entirely.
+    ///      - Return value changed from `(LpPosition[] memory, uint256)` (positions, reserves) to `(LpPosition[] memory, uint256)` (positions, totalAssetsSold).
+    /// @param tickLower The lower tick of the LP range set
+    /// @param tickUpper The upper tick of the LP range set
+    /// @param tickSpacing The tick spacing of the LP range set
+    /// @param isToken0 Whether the base asset is the token0 of the pair
+    /// @param discoverySupply The total supply of the base asset to be sold
+    /// @param totalPositions The total number of positions in the LP range set
+    /// @param newPositions The array of new positions to be created
+    /// @param positionOffset The starting index to update `newPositions`
+    /// @return newPositions The array of new positions to be created
+    /// @return totalAssetsSold The total assets used in the LP range set
+    function calculateLogNormalDistribution(
+        int24 tickLower,
+        int24 tickUpper,
+        int24 tickSpacing,
+        bool isToken0,
+        uint256 discoverySupply,
+        uint16 totalPositions,
+        LpPosition[] memory newPositions,
+        uint256 positionOffset
+    ) internal pure returns (LpPosition[] memory, uint256) {
+        int24 farTick = isToken0 ? tickUpper : tickLower;
+        int24 closeTick = isToken0 ? tickLower : tickUpper;
+
+        int24 spread = tickUpper - tickLower;
+
+        uint160 farSqrtPriceX96 = TickMath.getSqrtPriceAtTick(farTick);
+        uint256 amountPerPosition = FullMath.mulDiv(discoverySupply, MarketConstants.WAD, totalPositions * MarketConstants.WAD);
+        uint256 totalAssetsSold;
+
+        for (uint256 i; i < totalPositions; i++) {
+            // calculate the ticks position * 1/n to optimize the division
+            int24 startingTick = isToken0
+                ? closeTick + int24(uint24(FullMath.mulDiv(i, uint256(uint24(spread)), totalPositions)))
+                : closeTick - int24(uint24(FullMath.mulDiv(i, uint256(uint24(spread)), totalPositions)));
+
+            // round the tick to the nearest bin
+            startingTick = alignTickToTickSpacing(isToken0, startingTick, tickSpacing);
+
+            if (startingTick != farTick) {
+                uint160 startingSqrtPriceX96 = TickMath.getSqrtPriceAtTick(startingTick);
+
+                // if discoverySupply is 0, we skip the liquidity calculation as we are burning max liquidity
+                // in each position
+                uint128 liquidity;
+                if (discoverySupply != 0) {
+                    liquidity = isToken0
+                        ? LiquidityAmounts.getLiquidityForAmount0(startingSqrtPriceX96, farSqrtPriceX96, amountPerPosition)
+                        : LiquidityAmounts.getLiquidityForAmount1(farSqrtPriceX96, startingSqrtPriceX96, amountPerPosition);
+
+                    totalAssetsSold += (
+                        isToken0
+                            ? SqrtPriceMath.getAmount0Delta(startingSqrtPriceX96, farSqrtPriceX96, liquidity, true)
+                            : SqrtPriceMath.getAmount1Delta(farSqrtPriceX96, startingSqrtPriceX96, liquidity, true)
+                    );
+                }
+
+                int24 posFinalTickLower;
+                int24 posFinalTickUpper;
+                if (farSqrtPriceX96 < startingSqrtPriceX96) {
+                    posFinalTickLower = farTick;
+                    posFinalTickUpper = startingTick;
+                } else {
+                    posFinalTickLower = startingTick;
+                    posFinalTickUpper = farTick;
+                }
+
+                newPositions[positionOffset + i] = LpPosition({tickLower: posFinalTickLower, tickUpper: posFinalTickUpper, liquidity: liquidity});
+            }
+        }
+
+        require(totalAssetsSold <= discoverySupply, IDopplerErrors.CannotMintZeroLiquidity());
+
+        return (newPositions, totalAssetsSold);
+    }
+
+    /// @notice Calculates the final LP position that extends from the far tick to the pool's min/max tick
+    /// @dev This position ensures price equivalence between Uniswap v2 and v3 pools beyond the LBP range
+    /// @dev Changed from UniswapV3Initializer:
+    ///      - Removed parameters: `id`, `reserves`
+    ///      - Liquidity calculation is based *solely* on the provided `tailSupply` within the calculated tail tick range using `LiquidityAmounts.getLiquidityForAmount0` or `getLiquidityForAmount1`.
+    function calculateLpTail(
+        int24 tickLower,
+        int24 tickUpper,
+        bool isToken0,
+        uint256 tailSupply,
+        int24 tickSpacing
+    ) internal pure returns (LpPosition memory lpTail) {
+        int24 posTickLower = isToken0 ? tickUpper : alignTickToTickSpacing(false, TickMath.MIN_TICK, tickSpacing);
+        int24 posTickUpper = isToken0 ? alignTickToTickSpacing(true, TickMath.MAX_TICK, tickSpacing) : tickLower;
+
+        require(posTickLower < posTickUpper, IDopplerErrors.InvalidTickRangeMisordered(posTickLower, posTickUpper));
+
+        // Calculate the sqrtPrices for the tail range boundaries
+        uint160 sqrtPriceA = TickMath.getSqrtPriceAtTick(posTickLower);
+        uint160 sqrtPriceB = TickMath.getSqrtPriceAtTick(posTickUpper);
+
+        // Calculate liquidity only based on the tail range supply
+        uint128 lpTailLiquidity = isToken0
+            ? LiquidityAmounts.getLiquidityForAmount0(sqrtPriceA, sqrtPriceB, tailSupply)
+            : LiquidityAmounts.getLiquidityForAmount1(sqrtPriceA, sqrtPriceB, tailSupply);
+
+        lpTail = LpPosition({tickLower: posTickLower, tickUpper: posTickUpper, liquidity: lpTailLiquidity});
+    }
+
+    /// @notice Aligns a tick to the nearest tick spacing
+    /// @dev The tickSpacing parameter cannot be zero
+    /// @param isToken0 Whether the base asset is the token0 of the pair
+    /// @param tick The tick to align
+    /// @param tickSpacing The tick spacing of the pair
+    /// @return alignedTick The aligned tick
+    function alignTickToTickSpacing(bool isToken0, int24 tick, int24 tickSpacing) internal pure returns (int24) {
+        if (isToken0) {
+            // Round down if isToken0
+            if (tick < 0) {
+                // If the tick is negative, we round up (negatively) the negative result to round down
+                return ((tick - tickSpacing + 1) / tickSpacing) * tickSpacing;
+            } else {
+                // Else if positive, we simply round down
+                return (tick / tickSpacing) * tickSpacing;
+            }
+        } else {
+            // Round up if isToken1
+            if (tick < 0) {
+                // If the tick is negative, we round down the negative result to round up
+                return (tick / tickSpacing) * tickSpacing;
+            } else {
+                // Else if positive, we simply round up
+                return ((tick + tickSpacing - 1) / tickSpacing) * tickSpacing;
+            }
+        }
+    }
+}

package/src/libs/HooksDeployment.sol

@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
+import {ZoraV4CoinHook} from "../hooks/ZoraV4CoinHook.sol";
+import {HookMiner} from "@uniswap/v4-periphery/src/utils/HookMiner.sol";
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
+import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
+
+// copy of hook miner from v4 periphery
+library HookMinerWithCreationCodeArgs {
+    // mask to slice out the bottom 14 bit of the address
+    uint160 constant FLAG_MASK = Hooks.ALL_HOOK_MASK; // 0000 ... 0000 0011 1111 1111 1111
+
+    // Maximum number of iterations to find a salt, avoid infinite loops or MemoryOOG
+    // (arbitrarily set)
+    uint256 constant MAX_LOOP = 160_444;
+
+    /// @notice Find a salt that produces a hook address with the desired `flags`
+    /// @param deployer The address that will deploy the hook. In `forge test`, this will be the test contract `address(this)` or the pranking address
+    /// In `forge script`, this should be `0x4e59b44847b379578588920cA78FbF26c0B4956C` (CREATE2 Deployer Proxy)
+    /// @param flags The desired flags for the hook address. Example `uint160(Hooks.BEFORE_SWAP_FLAG | Hooks.AFTER_SWAP_FLAG | ...)`
+    /// @param creationCodeWithArgs The creation code of a hook contract, with encoded constructor arguments appended. Example: `abi.encodePacked(type(Counter).creationCode, abi.encode(constructorArg1, constructorArg2))`
+    /// @return (hookAddress, salt) The hook deploys to `hookAddress` when using `salt` with the syntax: `new Hook{salt: salt}(<constructor arguments>)`
+    function find(address deployer, uint160 flags, bytes memory creationCodeWithArgs) internal view returns (address, bytes32) {
+        flags = flags & FLAG_MASK; // mask for only the bottom 14 bits
+
+        address hookAddress;
+
+        bytes32 creationCodeHash = keccak256(creationCodeWithArgs);
+        for (uint256 salt; salt < MAX_LOOP; salt++) {
+            hookAddress = Create2.computeAddress(bytes32(salt), creationCodeHash, deployer);
+
+            // if the hook's bottom 14 bits match the desired flags AND the address does not have bytecode, we found a match
+            if (uint160(hookAddress) & FLAG_MASK == flags && hookAddress.code.length == 0) {
+                return (hookAddress, bytes32(salt));
+            }
+        }
+        revert("HookMiner: could not find salt");
+    }
+}
+
+library HooksDeployment {
+    error HookNotDeployed();
+    error InvalidHookAddress(address expected, address actual);
+
+    function deployZoraV4CoinHook(address deployer, bytes memory hookCreationCode) internal returns (IHooks hook) {
+        uint160 flags = uint160(Hooks.AFTER_SWAP_FLAG | Hooks.AFTER_INITIALIZE_FLAG) ^ (0x4444 << 144);
+
+        (address hookAddress, bytes32 salt) = HookMinerWithCreationCodeArgs.find(deployer, flags, hookCreationCode);
+
+        hook = IHooks(Create2.deploy(0, salt, hookCreationCode));
+
+        require(address(hook).code.length > 0, HookNotDeployed());
+
+        require(hookAddress == address(hook), InvalidHookAddress(hookAddress, address(hook)));
+    }
+
+    function zoraV4CoinHookCreationCode(
+        address poolManager,
+        address coinVersionLookup,
+        address[] memory trustedMessageSenders
+    ) internal pure returns (bytes memory) {
+        return abi.encodePacked(type(ZoraV4CoinHook).creationCode, abi.encode(poolManager, coinVersionLookup, trustedMessageSenders));
+    }
+
+    function deployZoraV4CoinHookFromContract(
+        address poolManager,
+        address coinVersionLookup,
+        address[] memory trustedMessageSenders
+    ) internal returns (IHooks hook) {
+        return deployZoraV4CoinHook(address(this), zoraV4CoinHookCreationCode(poolManager, coinVersionLookup, trustedMessageSenders));
+    }
+
+    function deployZoraV4CoinHookFromScript(
+        address poolManager,
+        address coinVersionLookup,
+        address[] memory trustedMessageSenders
+    ) internal returns (IHooks hook) {
+        address deployer = 0x4e59b44847b379578588920cA78FbF26c0B4956C;
+        return deployZoraV4CoinHook(deployer, zoraV4CoinHookCreationCode(poolManager, coinVersionLookup, trustedMessageSenders));
+    }
+}

package/src/libs/MarketConstants.sol

@@ -13,6 +13,10 @@ library MarketConstants {
     /// @dev 10000 basis points = 1%
     uint24 internal constant LP_FEE = 10000;
 
+    /// @notice The LP fee
+    /// @dev 20000 basis points = 2%
+    uint24 internal constant LP_FEE_V4 = 20000;
+
     /// @notice The spacing for 1% pools
     /// @dev 200 ticks
     int24 internal constant TICK_SPACING = 200;

package/src/libs/PoolStateReader.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol";
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {PoolId} from "@uniswap/v4-core/src/types/PoolId.sol";
+
+/// @title PoolStateReader
+/// @notice Library for reading state information from Uniswap V4 pools
+/// @dev Provides utility functions to extract specific pool state data without requiring full slot0 information
+library PoolStateReader {
+    /// @notice Retrieves the current square root price from a Uniswap V4 pool
+    /// @dev Gets the sqrtPriceX96 value from slot0 of the specified pool, discarding other slot0 data
+    /// @param key The PoolKey struct identifying the specific pool to query
+    /// @param poolManager The IPoolManager contract instance to query pool state from
+    /// @return sqrtPriceX96 The current square root price of the pool in X96 fixed-point format
+    function getSqrtPriceX96(PoolKey memory key, IPoolManager poolManager) internal view returns (uint160 sqrtPriceX96) {
+        PoolId poolId = key.toId();
+        (sqrtPriceX96, , , ) = StateLibrary.getSlot0(poolManager, poolId);
+    }
+}

package/src/libs/UniV3BuySell.sol

@@ -0,0 +1,231 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {ISwapRouter} from "../interfaces/ISwapRouter.sol";
+import {IWETH} from "../interfaces/IWETH.sol";
+import {MarketConstants} from "./MarketConstants.sol";
+import {CoinConstants} from "./CoinConstants.sol";
+import {ICoin} from "../interfaces/ICoin.sol";
+import {IProtocolRewards} from "../interfaces/IProtocolRewards.sol";
+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 {CoinV3Config} from "./CoinSetupV3.sol";
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+import {CoinDopplerUniV3} from "./CoinDopplerUniV3.sol";
+import {CoinConfigurationVersions} from "./CoinConfigurationVersions.sol";
+import {CoinRewards, CoinConfig} from "./CoinRewards.sol";
+struct SellResult {
+    uint256 payoutSize;
+    uint256 tradeReward;
+    uint256 trueOrderSize;
+}
+
+library UniV3BuySell {
+    using SafeERC20 for IERC20;
+
+    error AddressZero();
+    error InvalidPoolVersion();
+
+    function handleBuy(
+        address recipient,
+        uint256 orderSize,
+        uint256 minAmountOut,
+        uint160 sqrtPriceLimitX96,
+        address tradeReferrer,
+        CoinConfig memory coinConfig,
+        address currency,
+        ISwapRouter swapRouter,
+        IWETH weth
+    ) internal returns (uint256 amountOut, uint256 tradeReward, uint256 trueOrderSize) {
+        if (recipient == address(0)) {
+            revert AddressZero();
+        }
+
+        // Calculate the trade reward
+        tradeReward = _calculateReward(orderSize, CoinConstants.TOTAL_FEE_BPS);
+
+        // Calculate the remaining size
+        trueOrderSize = orderSize - tradeReward;
+
+        // Handle incoming currency
+        _handleIncomingCurrency(orderSize, trueOrderSize, currency, swapRouter, weth);
+
+        // Set up the swap parameters
+        ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({
+            tokenIn: currency,
+            tokenOut: address(this),
+            fee: MarketConstants.LP_FEE,
+            recipient: recipient,
+            amountIn: trueOrderSize,
+            amountOutMinimum: minAmountOut,
+            sqrtPriceLimitX96: sqrtPriceLimitX96
+        });
+
+        // Execute the swap
+        amountOut = ISwapRouter(swapRouter).exactInputSingle(params);
+
+        CoinRewards.handleTradeRewards(tradeReward, tradeReferrer, coinConfig, currency, weth);
+    }
+
+    function _executeSwap(
+        uint256 orderSize,
+        uint256 minAmountOut,
+        uint160 sqrtPriceLimitX96,
+        address currency,
+        ISwapRouter swapRouter
+    ) internal returns (uint256 amountOut) {
+        ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({
+            tokenIn: address(this),
+            tokenOut: currency,
+            fee: MarketConstants.LP_FEE,
+            recipient: address(this),
+            amountIn: orderSize,
+            amountOutMinimum: minAmountOut,
+            sqrtPriceLimitX96: sqrtPriceLimitX96
+        });
+
+        amountOut = swapRouter.exactInputSingle(params);
+    }
+
+    function _handleRefund(uint256 beforeCoinBalance, uint256 orderSize, address recipient) internal returns (uint256 trueOrderSize) {
+        uint256 afterCoinBalance = IERC20(address(this)).balanceOf(address(this));
+        trueOrderSize = orderSize;
+
+        if (afterCoinBalance > beforeCoinBalance) {
+            uint256 coinRefund = afterCoinBalance - beforeCoinBalance;
+            trueOrderSize -= coinRefund;
+            IERC20(address(this)).safeTransfer(recipient, coinRefund);
+        }
+    }
+
+    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);
+        }
+
+        tradeReward = _calculateReward(amountOut, CoinConstants.TOTAL_FEE_BPS);
+        payoutSize = amountOut - tradeReward;
+
+        _handlePayout(payoutSize, recipient, currency, weth);
+
+        CoinRewards.handleTradeRewards(tradeReward, tradeReferrer, coinConfig, currency, weth);
+    }
+
+    function handleSell(
+        address recipient,
+        uint256 beforeCoinBalance,
+        uint256 orderSize,
+        uint256 minAmountOut,
+        uint160 sqrtPriceLimitX96,
+        address tradeReferrer,
+        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, ISwapRouter swapRouter, IWETH weth) internal {
+        if (currency == address(weth) && msg.value > 0) {
+            if (msg.value != orderSize) {
+                revert ICoin.EthAmountMismatch();
+            }
+
+            if (msg.value < CoinConstants.MIN_ORDER_SIZE) {
+                revert ICoin.EthAmountTooSmall();
+            }
+
+            IWETH(weth).deposit{value: trueOrderSize}();
+            IWETH(weth).approve(address(swapRouter), trueOrderSize);
+        } else {
+            // Ensure ETH is not sent with a non-ETH pair
+            if (msg.value != 0) {
+                revert ICoin.EthTransferInvalid();
+            }
+
+            uint256 beforeBalance = IERC20(currency).balanceOf(address(this));
+            IERC20(currency).safeTransferFrom(msg.sender, address(this), orderSize);
+            uint256 afterBalance = IERC20(currency).balanceOf(address(this));
+
+            if ((afterBalance - beforeBalance) != orderSize) {
+                revert ICoin.ERC20TransferAmountMismatch();
+            }
+
+            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, IWETH weth) internal {
+        if (currency == address(weth)) {
+            Address.sendValue(payable(recipient), orderPayout);
+        } else {
+            IERC20(currency).safeTransfer(recipient, orderPayout);
+        }
+    }
+
+    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);
+
+            (uint256 amount0, uint256 amount1) = IUniswapV3Pool(poolAddress).collect(
+                address(this),
+                positions[i].tickLower,
+                positions[i].tickUpper,
+                type(uint128).max,
+                type(uint128).max
+            );
+
+            totalAmountToken0 += amount0;
+            totalAmountToken1 += amount1;
+        }
+    }
+
+    /// @dev Collects and distributes accrued fees from all LP positions
+    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);
+
+        address token0 = currency < coin ? currency : coin;
+        address token1 = currency < coin ? coin : currency;
+
+        rewards = CoinRewards.transferBothRewards(token0, totalAmountToken0, token1, totalAmountToken1, coin, coinConfig, currency, weth, doppler);
+
+        emit ICoin.CoinMarketRewards(coinConfig.payoutRecipient, coinConfig.platformReferrer, coinConfig.protocolRewardRecipient, currency, rewards);
+    }
+
+    function _calculateReward(uint256 amount, uint256 bps) internal pure returns (uint256) {
+        return CoinRewards.calculateReward(amount, bps);
+    }
+}

package/src/libs/UniV3Errors.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+library UniV3Errors {
+    error InvalidPoolAddress();
+    error InvalidCurrency();
+    error InvalidWeth();
+    error InvalidTickLower();
+    error InvalidTickUpper();
+    error InvalidUniswapV3Factory();
+}

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);
+    }
+}