@zoralabs/coins 0.7.1 → 0.9.0

package/src/libs/UniV3BuySell.sol

@@ -0,0 +1,449 @@
+// 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 {UniV3Config, 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;
+}
+
+library UniV3BuySell {
+    using SafeERC20 for IERC20;
+
+    error AddressZero();
+    error InvalidPoolVersion();
+
+    function _handleBuy(
+        address recipient,
+        uint256 orderSize,
+        uint256 minAmountOut,
+        uint160 sqrtPriceLimitX96,
+        address tradeReferrer,
+        address coin,
+        CoinConfig memory coinConfig
+    ) 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, coinConfig.currency, coinConfig.uniswapV3Config.weth, coinConfig.uniswapV3Config.swapRouter);
+
+        // Set up the swap parameters
+        ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({
+            tokenIn: coinConfig.currency,
+            tokenOut: coin,
+            fee: MarketConstants.LP_FEE,
+            recipient: recipient,
+            amountIn: trueOrderSize,
+            amountOutMinimum: minAmountOut,
+            sqrtPriceLimitX96: sqrtPriceLimitX96
+        });
+
+        // Execute the swap
+        amountOut = ISwapRouter(coinConfig.uniswapV3Config.swapRouter).exactInputSingle(params);
+
+        _handleTradeRewards(tradeReward, tradeReferrer, coinConfig);
+    }
+
+    /// @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,
+        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
+        ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({
+            tokenIn: address(this),
+            tokenOut: coinConfig.currency,
+            fee: MarketConstants.LP_FEE,
+            recipient: address(this),
+            amountIn: orderSize,
+            amountOutMinimum: minAmountOut,
+            sqrtPriceLimitX96: sqrtPriceLimitX96
+        });
+
+        // Execute the swap
+        uint256 amountOut = ISwapRouter(coinConfig.uniswapV3Config.swapRouter).exactInputSingle(params);
+
+        // Record the coin balance of this contract after the swap
+        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);
+        }
+
+        // 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);
+
+        _handleTradeRewards(tradeReward, tradeReferrer, coinConfig);
+    }
+
+    /// @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(
+        address recipient,
+        uint256 beforeCoinBalance,
+        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);
+    }
+
+    /// @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) {
+            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(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(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) {
+            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;
+
+        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(
+                address(this),
+                positions[i].tickLower,
+                positions[i].tickUpper,
+                type(uint128).max,
+                type(uint128).max
+            );
+
+            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);
+
+        return _distributeMarketRewards(positions, poolAddress, currency, coin, coinConfig);
+    }
+
+    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);
+            }
+        }
+
+        return 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();
+        }
+    }
+}

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/version/ContractVersionBase.sol

@@ -9,6 +9,6 @@ import {IVersionedContract} from "@zoralabs/shared-contracts/interfaces/IVersion
 contract ContractVersionBase is IVersionedContract {
     /// @notice The version of the contract
     function contractVersion() external pure override returns (string memory) {
-        return "0.7.1";
+        return "0.9.0";
     }
 }

package/test/Coin.t.sol

@@ -4,6 +4,7 @@ pragma solidity ^0.8.13;
 import "./utils/BaseTest.sol";
 import {ISwapRouter} from "../src/interfaces/ISwapRouter.sol";
 import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
+import {CoinConstants} from "../src/libs/CoinConstants.sol";
 
 contract CoinTest is BaseTest {
     function setUp() public override {
@@ -13,19 +14,19 @@ contract CoinTest is BaseTest {
     }
 
     function test_contract_version() public view {
-        assertEq(coin.contractVersion(), "0.7.1");
+        assertEq(coin.contractVersion(), "0.8.0");
     }
 
     function test_supply_constants() public view {
-        assertEq(MAX_TOTAL_SUPPLY, POOL_LAUNCH_SUPPLY + CREATOR_LAUNCH_REWARD);
+        assertEq(CoinConstants.MAX_TOTAL_SUPPLY, CoinConstants.POOL_LAUNCH_SUPPLY + CoinConstants.CREATOR_LAUNCH_REWARD);
 
-        assertEq(MAX_TOTAL_SUPPLY, 1_000_000_000e18);
-        assertEq(POOL_LAUNCH_SUPPLY, 990_000_000e18);
-        assertEq(CREATOR_LAUNCH_REWARD, 10_000_000e18);
+        assertEq(CoinConstants.MAX_TOTAL_SUPPLY, 1_000_000_000e18);
+        assertEq(CoinConstants.POOL_LAUNCH_SUPPLY, 990_000_000e18);
+        assertEq(CoinConstants.CREATOR_LAUNCH_REWARD, 10_000_000e18);
 
-        assertEq(coin.totalSupply(), MAX_TOTAL_SUPPLY);
-        assertEq(coin.balanceOf(coin.payoutRecipient()), CREATOR_LAUNCH_REWARD);
-        assertApproxEqAbs(coin.balanceOf(address(pool)), POOL_LAUNCH_SUPPLY, 1e18);
+        assertEq(coin.totalSupply(), CoinConstants.MAX_TOTAL_SUPPLY);
+        assertEq(coin.balanceOf(coin.payoutRecipient()), CoinConstants.CREATOR_LAUNCH_REWARD);
+        assertApproxEqAbs(coin.balanceOf(address(pool)), CoinConstants.POOL_LAUNCH_SUPPLY, 1e18);
     }
 
     function test_constructor_validation() public {
@@ -162,7 +163,7 @@ contract CoinTest is BaseTest {
     }
 
     function test_buy_with_eth_fuzz(uint256 ethOrderSize) public {
-        vm.assume(ethOrderSize >= MIN_ORDER_SIZE);
+        vm.assume(ethOrderSize >= CoinConstants.MIN_ORDER_SIZE);
         vm.assume(ethOrderSize < 10 ether);
 
         uint256 platformReferrerBalanceBeforeSale = users.platformReferrer.balance;
@@ -183,11 +184,11 @@ contract CoinTest is BaseTest {
 
     function test_buy_with_eth_too_small() public {
         vm.expectRevert(abi.encodeWithSelector(ICoin.EthAmountTooSmall.selector));
-        coin.buy{value: MIN_ORDER_SIZE - 1}(users.coinRecipient, MIN_ORDER_SIZE - 1, 0, 0, users.tradeReferrer);
+        coin.buy{value: CoinConstants.MIN_ORDER_SIZE - 1}(users.coinRecipient, CoinConstants.MIN_ORDER_SIZE - 1, 0, 0, users.tradeReferrer);
     }
 
     function test_buy_with_minimum_eth() public {
-        uint256 minEth = MIN_ORDER_SIZE;
+        uint256 minEth = CoinConstants.MIN_ORDER_SIZE;
         vm.deal(users.buyer, minEth);
         vm.prank(users.buyer);
         coin.buy{value: minEth}(users.coinRecipient, minEth, 0, 0, users.tradeReferrer);
@@ -236,7 +237,7 @@ contract CoinTest is BaseTest {
     }
 
     function test_buy_validate_return_amounts(uint256 orderSize) public {
-        vm.assume(orderSize >= MIN_ORDER_SIZE);
+        vm.assume(orderSize >= CoinConstants.MIN_ORDER_SIZE);
         vm.assume(orderSize < 10 ether);
 
         vm.deal(users.buyer, orderSize);
@@ -341,7 +342,7 @@ contract CoinTest is BaseTest {
 
     function test_sell_for_eth_fuzz(uint256 ethOrderSize) public {
         vm.assume(ethOrderSize < 10 ether);
-        vm.assume(ethOrderSize >= MIN_ORDER_SIZE);
+        vm.assume(ethOrderSize >= CoinConstants.MIN_ORDER_SIZE);
 
         vm.deal(users.buyer, ethOrderSize);
         vm.prank(users.buyer);
@@ -411,14 +412,14 @@ contract CoinTest is BaseTest {
         coin.buy{value: 0.001 ether}(users.creator, 0.001 ether, 0, 0, users.tradeReferrer);
 
         uint256 beforeBalance = coin.balanceOf(users.creator);
-        assertEq(beforeBalance, 11077349369032224007213331); // 11,077,349 coins
+        assertEq(beforeBalance, 11077349369032224007213331, "before balance"); // 11,077,349 coins
 
         vm.prank(users.creator);
         (uint256 amountSold, ) = coin.sell(users.creator, beforeBalance, 0, 0, users.tradeReferrer);
-        assertEq(amountSold, 1088231685891135360821548); // 1,088,232 coins (max that could be sold)
+        assertEq(amountSold, 1088231685891135360821548, "amountSold"); // 1,088,232 coins (max that could be sold)
 
         uint256 afterBalance = coin.balanceOf(users.creator);
-        assertEq(afterBalance, 9994558841570544323195890); // 9,994,559 coins
+        assertEq(afterBalance, 9994558841570544323195890, "after balance"); // 9,994,559 coins
 
         uint256 expectedMarketReward = 5441158429455676804107; // 5,441 coins
 
@@ -512,7 +513,9 @@ contract CoinTest is BaseTest {
     function test_eth_transfer_fail() public {
         vm.deal(users.buyer, 1 ether);
         vm.prank(users.buyer);
-        coin.buy{value: 1 ether}(users.coinRecipient, 1 ether, 0, 0, users.tradeReferrer);
+        (, uint256 amountOut) = coin.buy{value: 1 ether}(users.coinRecipient, 1 ether, 0, 0, users.tradeReferrer);
+
+        assertEq(coin.balanceOf(users.coinRecipient), amountOut);
 
         // Recipient reverts on ETH receive
         address payable badRecipient = payable(makeAddr("badRecipient"));

package/test/CoinDopplerUniV3.t.sol

@@ -5,6 +5,7 @@ import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.s
 import {MarketConstants} from "../src/libs/MarketConstants.sol";
 import {BaseTest} from "./utils/BaseTest.sol";
 import {Coin} from "../src/Coin.sol";
+import {CoinConstants} from "../src/libs/CoinConstants.sol";
 import {IUniswapV3Pool} from "../src/interfaces/IUniswapV3Pool.sol";
 import {LpPosition} from "../src/types/LpPosition.sol";
 import {IDopplerErrors} from "../src/interfaces/IDopplerErrors.sol";
@@ -17,17 +18,6 @@ contract DopplerUniswapV3Test is BaseTest {
     uint16 internal constant DEFAULT_NUM_DISCOVERY_POSITIONS = 10; // will be 11 total with tail position
     uint256 internal constant DEFAULT_DISCOVERY_SUPPLY_SHARE = 0.495e18; // half of the 990m total pool supply
 
-    function _generatePoolConfig(
-        uint8 version_,
-        address currency_,
-        int24 tickLower_,
-        int24 tickUpper_,
-        uint16 numDiscoveryPositions_,
-        uint256 maxDiscoverySupplyShare_
-    ) internal pure returns (bytes memory) {
-        return abi.encode(version_, currency_, tickLower_, tickUpper_, numDiscoveryPositions_, maxDiscoverySupplyShare_);
-    }
-
     function _deployCoin(bytes memory poolConfig_) internal {
         vm.prank(users.creator);
         (address coinAddress, ) = factory.deploy(
@@ -87,7 +77,7 @@ contract DopplerUniswapV3Test is BaseTest {
         assertTrue(isInitialized);
         assertFalse(isExited);
         assertEq(maxShareToBeSold, 0);
-        assertEq(totalTokensOnBondingCurve, POOL_LAUNCH_SUPPLY);
+        assertEq(totalTokensOnBondingCurve, CoinConstants.POOL_LAUNCH_SUPPLY);
 
         bool isCoinToken0 = address(coin) < address(weth);
 
@@ -116,7 +106,7 @@ contract DopplerUniswapV3Test is BaseTest {
     }
 
     function test_deploy_legacy_eth_config_with_prebuy(uint256 initialOrderSize) public {
-        vm.assume(initialOrderSize > MIN_ORDER_SIZE);
+        vm.assume(initialOrderSize > CoinConstants.MIN_ORDER_SIZE);
         vm.assume(initialOrderSize < 10 ether);
 
         vm.deal(users.creator, initialOrderSize);
@@ -176,7 +166,7 @@ contract DopplerUniswapV3Test is BaseTest {
         vm.label(address(pool), "POOL");
 
         assertEq(coin.currency(), address(usdc), "currency");
-        assertEq(coin.balanceOf(users.creator), CREATOR_LAUNCH_REWARD + coinsPurchased);
+        assertEq(coin.balanceOf(users.creator), CoinConstants.CREATOR_LAUNCH_REWARD + coinsPurchased);
     }
 
     function test_deploy_doppler_eth() public {
@@ -209,11 +199,11 @@ contract DopplerUniswapV3Test is BaseTest {
         assertTrue(isInitialized, "poolState.isInitialized");
         assertFalse(isExited, "poolState.isExited");
         assertEq(maxShareToBeSold, DEFAULT_DISCOVERY_SUPPLY_SHARE, "poolState.maxShareToBeSold");
-        assertEq(totalTokensOnBondingCurve, POOL_LAUNCH_SUPPLY, "poolState.totalTokensOnBondingCurve");
+        assertEq(totalTokensOnBondingCurve, CoinConstants.POOL_LAUNCH_SUPPLY, "poolState.totalTokensOnBondingCurve");
     }
 
     function test_deploy_doppler_eth_with_prebuy(uint256 initialOrderSize) public {
-        vm.assume(initialOrderSize > MIN_ORDER_SIZE);
+        vm.assume(initialOrderSize > CoinConstants.MIN_ORDER_SIZE);
         vm.assume(initialOrderSize < 1 ether);
 
         vm.deal(users.creator, initialOrderSize);
@@ -244,7 +234,7 @@ contract DopplerUniswapV3Test is BaseTest {
 
         assertEq(coin.currency(), address(weth), "currency");
         assertGt(coinsPurchased, 0, "coinsPurchased > 0");
-        assertEq(coin.balanceOf(users.creator), CREATOR_LAUNCH_REWARD + coinsPurchased, "balanceOf creator");
+        assertEq(coin.balanceOf(users.creator), CoinConstants.CREATOR_LAUNCH_REWARD + coinsPurchased, "balanceOf creator");
         assertGt(weth.balanceOf(address(pool)), 0, "Pool WETH balance");
     }
 

package/test/Factory.t.sol

@@ -2,6 +2,7 @@
 pragma solidity ^0.8.13;
 
 import "./utils/BaseTest.sol";
+import {CoinConstants} from "../src/libs/CoinConstants.sol";
 
 contract FactoryTest is BaseTest {
     function setUp() public override {
@@ -58,7 +59,7 @@ contract FactoryTest is BaseTest {
     }
 
     function test_deploy_with_eth(uint256 initialOrderSize) public {
-        vm.assume(initialOrderSize > MIN_ORDER_SIZE);
+        vm.assume(initialOrderSize > CoinConstants.MIN_ORDER_SIZE);
         vm.assume(initialOrderSize < 10 ether);
 
         address[] memory owners = new address[](1);
@@ -97,7 +98,7 @@ contract FactoryTest is BaseTest {
     }
 
     function test_deploy_with_weth(uint256 initialOrderSize) public {
-        vm.assume(initialOrderSize > MIN_ORDER_SIZE);
+        vm.assume(initialOrderSize > CoinConstants.MIN_ORDER_SIZE);
         vm.assume(initialOrderSize < 10 ether);
 
         address[] memory owners = new address[](1);
@@ -203,7 +204,7 @@ contract FactoryTest is BaseTest {
         vm.label(address(pool), "POOL");
 
         assertEq(coin.currency(), USDC_ADDRESS, "currency");
-        assertEq(coin.balanceOf(users.creator), CREATOR_LAUNCH_REWARD + coinsPurchased);
+        assertEq(coin.balanceOf(users.creator), CoinConstants.CREATOR_LAUNCH_REWARD + coinsPurchased);
     }
 
     function test_deploy_with_usdc_revert_payout_recipient_zero() public {