@zoralabs/coins 0.6.1 → 0.7.0

package/src/utils/uniswap/TickMath.sol

@@ -0,0 +1,244 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {BitMath} from "./BitMath.sol";
+import {CustomRevert} from "./CustomRevert.sol";
+
+/// @dev https://github.com/Uniswap/v4-core/blob/80311e34080fee64b6fc6c916e9a51a437d0e482/src/libraries/TickMath.sol
+/// @title Math library for computing sqrt prices from ticks and vice versa
+/// @notice Computes sqrt price for ticks of size 1.0001, i.e. sqrt(1.0001^tick) as fixed point Q64.96 numbers. Supports
+/// prices between 2**-128 and 2**128
+library TickMath {
+    using CustomRevert for bytes4;
+
+    /// @notice Thrown when the tick passed to #getSqrtPriceAtTick is not between MIN_TICK and MAX_TICK
+    error InvalidTick(int24 tick);
+    /// @notice Thrown when the price passed to #getTickAtSqrtPrice does not correspond to a price between MIN_TICK and MAX_TICK
+    error InvalidSqrtPrice(uint160 sqrtPriceX96);
+
+    /// @dev The minimum tick that may be passed to #getSqrtPriceAtTick computed from log base 1.0001 of 2**-128
+    /// @dev If ever MIN_TICK and MAX_TICK are not centered around 0, the absTick logic in getSqrtPriceAtTick cannot be used
+    int24 internal constant MIN_TICK = -887272;
+    /// @dev The maximum tick that may be passed to #getSqrtPriceAtTick computed from log base 1.0001 of 2**128
+    /// @dev If ever MIN_TICK and MAX_TICK are not centered around 0, the absTick logic in getSqrtPriceAtTick cannot be used
+    int24 internal constant MAX_TICK = 887272;
+
+    /// @dev The minimum tick spacing value drawn from the range of type int16 that is greater than 0, i.e. min from the range [1, 32767]
+    int24 internal constant MIN_TICK_SPACING = 1;
+    /// @dev The maximum tick spacing value drawn from the range of type int16, i.e. max from the range [1, 32767]
+    int24 internal constant MAX_TICK_SPACING = type(int16).max;
+
+    /// @dev The minimum value that can be returned from #getSqrtPriceAtTick. Equivalent to getSqrtPriceAtTick(MIN_TICK)
+    uint160 internal constant MIN_SQRT_PRICE = 4295128739;
+    /// @dev The maximum value that can be returned from #getSqrtPriceAtTick. Equivalent to getSqrtPriceAtTick(MAX_TICK)
+    uint160 internal constant MAX_SQRT_PRICE = 1461446703485210103287273052203988822378723970342;
+    /// @dev A threshold used for optimized bounds check, equals `MAX_SQRT_PRICE - MIN_SQRT_PRICE - 1`
+    uint160 internal constant MAX_SQRT_PRICE_MINUS_MIN_SQRT_PRICE_MINUS_ONE = 1461446703485210103287273052203988822378723970342 - 4295128739 - 1;
+
+    /// @notice Given a tickSpacing, compute the maximum usable tick
+    function maxUsableTick(int24 tickSpacing) internal pure returns (int24) {
+        unchecked {
+            return (MAX_TICK / tickSpacing) * tickSpacing;
+        }
+    }
+
+    /// @notice Given a tickSpacing, compute the minimum usable tick
+    function minUsableTick(int24 tickSpacing) internal pure returns (int24) {
+        unchecked {
+            return (MIN_TICK / tickSpacing) * tickSpacing;
+        }
+    }
+
+    /// @notice Calculates sqrt(1.0001^tick) * 2^96
+    /// @dev Throws if |tick| > max tick
+    /// @param tick The input tick for the above formula
+    /// @return sqrtPriceX96 A Fixed point Q64.96 number representing the sqrt of the price of the two assets (currency1/currency0)
+    /// at the given tick
+    function getSqrtPriceAtTick(int24 tick) internal pure returns (uint160 sqrtPriceX96) {
+        unchecked {
+            uint256 absTick;
+            assembly ("memory-safe") {
+                tick := signextend(2, tick)
+                // mask = 0 if tick >= 0 else -1 (all 1s)
+                let mask := sar(255, tick)
+                // if tick >= 0, |tick| = tick = 0 ^ tick
+                // if tick < 0, |tick| = ~~|tick| = ~(-|tick| - 1) = ~(tick - 1) = (-1) ^ (tick - 1)
+                // either way, |tick| = mask ^ (tick + mask)
+                absTick := xor(mask, add(mask, tick))
+            }
+
+            if (absTick > uint256(int256(MAX_TICK))) InvalidTick.selector.revertWith(tick);
+
+            // The tick is decomposed into bits, and for each bit with index i that is set, the product of 1/sqrt(1.0001^(2^i))
+            // is calculated (using Q128.128). The constants used for this calculation are rounded to the nearest integer
+
+            // Equivalent to:
+            //     price = absTick & 0x1 != 0 ? 0xfffcb933bd6fad37aa2d162d1a594001 : 0x100000000000000000000000000000000;
+            //     or price = int(2**128 / sqrt(1.0001)) if (absTick & 0x1) else 1 << 128
+            uint256 price;
+            assembly ("memory-safe") {
+                price := xor(shl(128, 1), mul(xor(shl(128, 1), 0xfffcb933bd6fad37aa2d162d1a594001), and(absTick, 0x1)))
+            }
+            if (absTick & 0x2 != 0) price = (price * 0xfff97272373d413259a46990580e213a) >> 128;
+            if (absTick & 0x4 != 0) price = (price * 0xfff2e50f5f656932ef12357cf3c7fdcc) >> 128;
+            if (absTick & 0x8 != 0) price = (price * 0xffe5caca7e10e4e61c3624eaa0941cd0) >> 128;
+            if (absTick & 0x10 != 0) price = (price * 0xffcb9843d60f6159c9db58835c926644) >> 128;
+            if (absTick & 0x20 != 0) price = (price * 0xff973b41fa98c081472e6896dfb254c0) >> 128;
+            if (absTick & 0x40 != 0) price = (price * 0xff2ea16466c96a3843ec78b326b52861) >> 128;
+            if (absTick & 0x80 != 0) price = (price * 0xfe5dee046a99a2a811c461f1969c3053) >> 128;
+            if (absTick & 0x100 != 0) price = (price * 0xfcbe86c7900a88aedcffc83b479aa3a4) >> 128;
+            if (absTick & 0x200 != 0) price = (price * 0xf987a7253ac413176f2b074cf7815e54) >> 128;
+            if (absTick & 0x400 != 0) price = (price * 0xf3392b0822b70005940c7a398e4b70f3) >> 128;
+            if (absTick & 0x800 != 0) price = (price * 0xe7159475a2c29b7443b29c7fa6e889d9) >> 128;
+            if (absTick & 0x1000 != 0) price = (price * 0xd097f3bdfd2022b8845ad8f792aa5825) >> 128;
+            if (absTick & 0x2000 != 0) price = (price * 0xa9f746462d870fdf8a65dc1f90e061e5) >> 128;
+            if (absTick & 0x4000 != 0) price = (price * 0x70d869a156d2a1b890bb3df62baf32f7) >> 128;
+            if (absTick & 0x8000 != 0) price = (price * 0x31be135f97d08fd981231505542fcfa6) >> 128;
+            if (absTick & 0x10000 != 0) price = (price * 0x9aa508b5b7a84e1c677de54f3e99bc9) >> 128;
+            if (absTick & 0x20000 != 0) price = (price * 0x5d6af8dedb81196699c329225ee604) >> 128;
+            if (absTick & 0x40000 != 0) price = (price * 0x2216e584f5fa1ea926041bedfe98) >> 128;
+            if (absTick & 0x80000 != 0) price = (price * 0x48a170391f7dc42444e8fa2) >> 128;
+
+            assembly ("memory-safe") {
+                // if (tick > 0) price = type(uint256).max / price;
+                if sgt(tick, 0) {
+                    price := div(not(0), price)
+                }
+
+                // this divides by 1<<32 rounding up to go from a Q128.128 to a Q128.96.
+                // we then downcast because we know the result always fits within 160 bits due to our tick input constraint
+                // we round up in the division so getTickAtSqrtPrice of the output price is always consistent
+                // `sub(shl(32, 1), 1)` is `type(uint32).max`
+                // `price + type(uint32).max` will not overflow because `price` fits in 192 bits
+                sqrtPriceX96 := shr(32, add(price, sub(shl(32, 1), 1)))
+            }
+        }
+    }
+
+    /// @notice Calculates the greatest tick value such that getSqrtPriceAtTick(tick) <= sqrtPriceX96
+    /// @dev Throws in case sqrtPriceX96 < MIN_SQRT_PRICE, as MIN_SQRT_PRICE is the lowest value getSqrtPriceAtTick may
+    /// ever return.
+    /// @param sqrtPriceX96 The sqrt price for which to compute the tick as a Q64.96
+    /// @return tick The greatest tick for which the getSqrtPriceAtTick(tick) is less than or equal to the input sqrtPriceX96
+    function getTickAtSqrtPrice(uint160 sqrtPriceX96) internal pure returns (int24 tick) {
+        unchecked {
+            // Equivalent: if (sqrtPriceX96 < MIN_SQRT_PRICE || sqrtPriceX96 >= MAX_SQRT_PRICE) revert InvalidSqrtPrice();
+            // second inequality must be >= because the price can never reach the price at the max tick
+            // if sqrtPriceX96 < MIN_SQRT_PRICE, the `sub` underflows and `gt` is true
+            // if sqrtPriceX96 >= MAX_SQRT_PRICE, sqrtPriceX96 - MIN_SQRT_PRICE > MAX_SQRT_PRICE - MIN_SQRT_PRICE - 1
+            if ((sqrtPriceX96 - MIN_SQRT_PRICE) > MAX_SQRT_PRICE_MINUS_MIN_SQRT_PRICE_MINUS_ONE) {
+                InvalidSqrtPrice.selector.revertWith(sqrtPriceX96);
+            }
+
+            uint256 price = uint256(sqrtPriceX96) << 32;
+
+            uint256 r = price;
+            uint256 msb = BitMath.mostSignificantBit(r);
+
+            if (msb >= 128) r = price >> (msb - 127);
+            else r = price << (127 - msb);
+
+            int256 log_2 = (int256(msb) - 128) << 64;
+
+            assembly ("memory-safe") {
+                r := shr(127, mul(r, r))
+                let f := shr(128, r)
+                log_2 := or(log_2, shl(63, f))
+                r := shr(f, r)
+            }
+            assembly ("memory-safe") {
+                r := shr(127, mul(r, r))
+                let f := shr(128, r)
+                log_2 := or(log_2, shl(62, f))
+                r := shr(f, r)
+            }
+            assembly ("memory-safe") {
+                r := shr(127, mul(r, r))
+                let f := shr(128, r)
+                log_2 := or(log_2, shl(61, f))
+                r := shr(f, r)
+            }
+            assembly ("memory-safe") {
+                r := shr(127, mul(r, r))
+                let f := shr(128, r)
+                log_2 := or(log_2, shl(60, f))
+                r := shr(f, r)
+            }
+            assembly ("memory-safe") {
+                r := shr(127, mul(r, r))
+                let f := shr(128, r)
+                log_2 := or(log_2, shl(59, f))
+                r := shr(f, r)
+            }
+            assembly ("memory-safe") {
+                r := shr(127, mul(r, r))
+                let f := shr(128, r)
+                log_2 := or(log_2, shl(58, f))
+                r := shr(f, r)
+            }
+            assembly ("memory-safe") {
+                r := shr(127, mul(r, r))
+                let f := shr(128, r)
+                log_2 := or(log_2, shl(57, f))
+                r := shr(f, r)
+            }
+            assembly ("memory-safe") {
+                r := shr(127, mul(r, r))
+                let f := shr(128, r)
+                log_2 := or(log_2, shl(56, f))
+                r := shr(f, r)
+            }
+            assembly ("memory-safe") {
+                r := shr(127, mul(r, r))
+                let f := shr(128, r)
+                log_2 := or(log_2, shl(55, f))
+                r := shr(f, r)
+            }
+            assembly ("memory-safe") {
+                r := shr(127, mul(r, r))
+                let f := shr(128, r)
+                log_2 := or(log_2, shl(54, f))
+                r := shr(f, r)
+            }
+            assembly ("memory-safe") {
+                r := shr(127, mul(r, r))
+                let f := shr(128, r)
+                log_2 := or(log_2, shl(53, f))
+                r := shr(f, r)
+            }
+            assembly ("memory-safe") {
+                r := shr(127, mul(r, r))
+                let f := shr(128, r)
+                log_2 := or(log_2, shl(52, f))
+                r := shr(f, r)
+            }
+            assembly ("memory-safe") {
+                r := shr(127, mul(r, r))
+                let f := shr(128, r)
+                log_2 := or(log_2, shl(51, f))
+                r := shr(f, r)
+            }
+            assembly ("memory-safe") {
+                r := shr(127, mul(r, r))
+                let f := shr(128, r)
+                log_2 := or(log_2, shl(50, f))
+            }
+
+            int256 log_sqrt10001 = log_2 * 255738958999603826347141; // Q22.128 number
+
+            // Magic number represents the ceiling of the maximum value of the error when approximating log_sqrt10001(x)
+            int24 tickLow = int24((log_sqrt10001 - 3402992956809132418596140100660247210) >> 128);
+
+            // Magic number represents the minimum value of the error when approximating log_sqrt10001(x), when
+            // sqrtPrice is from the range (2^-64, 2^64). This is safe as MIN_SQRT_PRICE is more than 2^-64. If MIN_SQRT_PRICE
+            // is changed, this may need to be changed too
+            int24 tickHi = int24((log_sqrt10001 + 291339464771989622907027621153398088495) >> 128);
+
+            tick = tickLow == tickHi
+                ? tickLow
+                : getSqrtPriceAtTick(tickHi) <= sqrtPriceX96
+                    ? tickHi
+                    : tickLow;
+        }
+    }
+}

package/src/utils/uniswap/UnsafeMath.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @dev https://github.com/Uniswap/v4-core/blob/80311e34080fee64b6fc6c916e9a51a437d0e482/src/libraries/UnsafeMath.sol
+/// @title Math functions that do not check inputs or outputs
+/// @notice Contains methods that perform common math functions but do not do any overflow or underflow checks
+library UnsafeMath {
+    /// @notice Returns ceil(x / y)
+    /// @dev division by 0 will return 0, and should be checked externally
+    /// @param x The dividend
+    /// @param y The divisor
+    /// @return z The quotient, ceil(x / y)
+    function divRoundingUp(uint256 x, uint256 y) internal pure returns (uint256 z) {
+        assembly ("memory-safe") {
+            z := add(div(x, y), gt(mod(x, y), 0))
+        }
+    }
+
+    /// @notice Calculates floor(a×b÷denominator)
+    /// @dev division by 0 will return 0, and should be checked externally
+    /// @param a The multiplicand
+    /// @param b The multiplier
+    /// @param denominator The divisor
+    /// @return result The 256-bit result, floor(a×b÷denominator)
+    function simpleMulDiv(uint256 a, uint256 b, uint256 denominator) internal pure returns (uint256 result) {
+        assembly ("memory-safe") {
+            result := div(mul(a, b), denominator)
+        }
+    }
+}

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.6.1";
+        return "0.7.0";
     }
 }

package/test/Coin.t.sol

@@ -12,7 +12,7 @@ contract CoinTest is BaseTest {
     }
 
     function test_contract_version() public view {
-        assertEq(coin.contractVersion(), "0.6.0");
+        assertEq(coin.contractVersion(), "0.7.0");
     }
 
     function test_supply_constants() public view {
@@ -29,25 +29,27 @@ contract CoinTest is BaseTest {
 
     function test_constructor_validation() public {
         vm.expectRevert(abi.encodeWithSelector(ICoin.AddressZero.selector));
-        new Coin(address(0), address(protocolRewards), WETH_ADDRESS, NONFUNGIBLE_POSITION_MANAGER, SWAP_ROUTER);
+        new Coin(address(0), address(protocolRewards), WETH_ADDRESS, NONFUNGIBLE_POSITION_MANAGER, SWAP_ROUTER, DOPPLER_AIRLOCK);
 
         vm.expectRevert(abi.encodeWithSelector(ICoin.AddressZero.selector));
-        new Coin(users.feeRecipient, address(0), WETH_ADDRESS, NONFUNGIBLE_POSITION_MANAGER, SWAP_ROUTER);
+        new Coin(users.feeRecipient, address(0), WETH_ADDRESS, NONFUNGIBLE_POSITION_MANAGER, SWAP_ROUTER, DOPPLER_AIRLOCK);
 
         vm.expectRevert(abi.encodeWithSelector(ICoin.AddressZero.selector));
-        new Coin(users.feeRecipient, address(protocolRewards), address(0), NONFUNGIBLE_POSITION_MANAGER, SWAP_ROUTER);
+        new Coin(users.feeRecipient, address(protocolRewards), address(0), NONFUNGIBLE_POSITION_MANAGER, SWAP_ROUTER, DOPPLER_AIRLOCK);
 
         vm.expectRevert(abi.encodeWithSelector(ICoin.AddressZero.selector));
-        new Coin(users.feeRecipient, address(protocolRewards), WETH_ADDRESS, address(0), SWAP_ROUTER);
+        new Coin(users.feeRecipient, address(protocolRewards), WETH_ADDRESS, address(0), SWAP_ROUTER, DOPPLER_AIRLOCK);
 
         vm.expectRevert(abi.encodeWithSelector(ICoin.AddressZero.selector));
-        new Coin(users.feeRecipient, address(protocolRewards), WETH_ADDRESS, NONFUNGIBLE_POSITION_MANAGER, address(0));
+        new Coin(users.feeRecipient, address(protocolRewards), WETH_ADDRESS, NONFUNGIBLE_POSITION_MANAGER, address(0), DOPPLER_AIRLOCK);
 
-        Coin newToken = new Coin(users.feeRecipient, address(protocolRewards), WETH_ADDRESS, NONFUNGIBLE_POSITION_MANAGER, SWAP_ROUTER);
+        vm.expectRevert(abi.encodeWithSelector(ICoin.AddressZero.selector));
+        new Coin(users.feeRecipient, address(protocolRewards), WETH_ADDRESS, NONFUNGIBLE_POSITION_MANAGER, SWAP_ROUTER, address(0));
+
+        Coin newToken = new Coin(users.feeRecipient, address(protocolRewards), WETH_ADDRESS, NONFUNGIBLE_POSITION_MANAGER, SWAP_ROUTER, DOPPLER_AIRLOCK);
         assertEq(address(newToken.protocolRewardRecipient()), users.feeRecipient);
         assertEq(address(newToken.protocolRewards()), address(protocolRewards));
         assertEq(address(newToken.WETH()), WETH_ADDRESS);
-        assertEq(address(newToken.nonfungiblePositionManager()), NONFUNGIBLE_POSITION_MANAGER);
         assertEq(address(newToken.swapRouter()), SWAP_ROUTER);
     }
 
@@ -64,12 +66,22 @@ contract CoinTest is BaseTest {
             "INIT",
             users.platformReferrer,
             address(weth),
-            LP_TICK_LOWER_WETH,
+            MarketConstants.LP_TICK_LOWER_WETH,
             0
         );
         coin = Coin(payable(coinAddress));
 
-        (coinAddress, ) = factory.deploy(users.creator, owners, "https://init.com", "Init Token", "INIT", address(0), address(weth), LP_TICK_LOWER_WETH, 0);
+        (coinAddress, ) = factory.deploy(
+            users.creator,
+            owners,
+            "https://init.com",
+            "Init Token",
+            "INIT",
+            address(0),
+            address(weth),
+            MarketConstants.LP_TICK_LOWER_WETH,
+            0
+        );
         coin = Coin(payable(coinAddress));
 
         assertEq(coin.payoutRecipient(), users.creator);
@@ -91,13 +103,33 @@ contract CoinTest is BaseTest {
             "INIT",
             users.platformReferrer,
             address(weth),
-            LP_TICK_LOWER_WETH,
+            MarketConstants.LP_TICK_LOWER_WETH,
             0
         );
         coin = Coin(payable(coinAddress));
 
         vm.expectRevert(abi.encodeWithSignature("InvalidInitialization()"));
-        coin.initialize(users.creator, new address[](0), "https://init.com", "Init Token", "INIT", users.platformReferrer, address(weth), LP_TICK_LOWER_WETH);
+        coin.initialize(users.creator, owners, "https://init.com", "Init Token", "INIT", abi.encode(""), users.platformReferrer);
+    }
+
+    function test_revert_pool_exists() public {
+        address[] memory owners = new address[](1);
+        owners[0] = users.creator;
+
+        vm.etch(address(0x1C61DAa59b45525d4fb139106EFEC97c2D8De9be), abi.encode(bytes32(uint256(1))));
+
+        vm.expectRevert();
+        factory.deploy(
+            users.creator,
+            owners,
+            "https://init.com",
+            "Init Token",
+            "INIT",
+            users.platformReferrer,
+            address(weth),
+            MarketConstants.LP_TICK_LOWER_WETH,
+            0
+        );
     }
 
     function test_erc165_interface_support() public view {
@@ -209,11 +241,13 @@ contract CoinTest is BaseTest {
         vm.prank(users.buyer);
         weth.approve(address(swapRouter), 100_000);
 
+        assertEq(coin.balanceOf(users.buyer), 0, "buyer coin balance initial");
+
         // Set up the swap parameters
         ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({
             tokenIn: WETH_ADDRESS,
             tokenOut: address(coin),
-            fee: LP_FEE,
+            fee: MarketConstants.LP_FEE,
             recipient: address(users.buyer),
             amountIn: 100_000,
             amountOutMinimum: 0,
@@ -235,7 +269,8 @@ contract CoinTest is BaseTest {
         coin.claimSecondaryRewards(false);
         assertEq(protocolRewards.balanceOf(users.creator), 499);
         assertEq(protocolRewards.balanceOf(users.platformReferrer), 249);
-        assertEq(protocolRewards.balanceOf(users.feeRecipient), 251);
+        assertEq(protocolRewards.balanceOf(users.feeRecipient), 202);
+        assertEq(dopplerFeeRecipient().balance, 49);
     }
 
     function test_sell_for_eth_direct_and_claim_secondary_push_eth() public {
@@ -251,7 +286,7 @@ contract CoinTest is BaseTest {
         ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({
             tokenIn: WETH_ADDRESS,
             tokenOut: address(coin),
-            fee: LP_FEE,
+            fee: MarketConstants.LP_FEE,
             recipient: address(users.buyer),
             amountIn: 100_000,
             amountOutMinimum: 0,
@@ -406,11 +441,6 @@ contract CoinTest is BaseTest {
         assertTrue(success);
     }
 
-    function test_only_pool_callback() public {
-        vm.expectRevert(abi.encodeWithSelector(ICoin.OnlyPool.selector));
-        coin.onERC721Received(address(0), address(0), 0, "");
-    }
-
     function test_default_platform_referrer() public {
         address[] memory owners = new address[](1);
         owners[0] = users.creator;
@@ -423,7 +453,7 @@ contract CoinTest is BaseTest {
             "TEST",
             users.platformReferrer,
             address(weth),
-            LP_TICK_LOWER_WETH,
+            MarketConstants.LP_TICK_LOWER_WETH,
             0
         );
         Coin newCoin = Coin(payable(newCoinAddr));
@@ -438,42 +468,6 @@ contract CoinTest is BaseTest {
         assertGt(protocolRewards.balanceOf(users.feeRecipient), expectedFees.platformReferrer, "feeRecipient eth balance");
     }
 
-    function test_invalid_weth_tick() public {
-        address[] memory owners = new address[](1);
-        owners[0] = users.creator;
-
-        vm.expectRevert(ICoin.InvalidWethLowerTick.selector);
-        (address newCoinAddr, ) = factory.deploy(
-            users.creator,
-            owners,
-            "https://test.com",
-            "Test Token",
-            "TEST",
-            users.platformReferrer,
-            address(weth),
-            LP_TICK_LOWER_WETH - 1,
-            0
-        );
-    }
-
-    function test_invalid_currency_tick() public {
-        address[] memory owners = new address[](1);
-        owners[0] = users.creator;
-
-        vm.expectRevert(ICoin.InvalidCurrencyLowerTick.selector);
-        (address newCoinAddr, ) = factory.deploy(
-            users.creator,
-            owners,
-            "https://test.com",
-            "Test Token",
-            "TEST",
-            users.platformReferrer,
-            address(0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913),
-            20,
-            0
-        );
-    }
-
     function test_default_order_referrer() public {
         vm.deal(users.buyer, 1 ether);
         vm.prank(users.buyer);
@@ -500,12 +494,6 @@ contract CoinTest is BaseTest {
         coin.sell(users.coinRecipient, 1e18, type(uint256).max, 0, users.tradeReferrer);
     }
 
-    function test_uniswap_swap_callback() public {
-        // Test swap callback
-        vm.prank(address(pool));
-        coin.uniswapV3SwapCallback(100, -100, "");
-    }
-
     function test_eth_transfer_fail() public {
         vm.deal(users.buyer, 1 ether);
         vm.prank(users.buyer);
@@ -524,7 +512,8 @@ contract CoinTest is BaseTest {
         vm.deal(users.buyer, 1 ether);
         vm.prank(users.buyer);
         vm.expectRevert(abi.encodeWithSelector(ICoin.OnlyWeth.selector));
-        address(coin).call{value: 1 ether}("");
+        (bool ignoredSuccess, ) = address(coin).call{value: 1 ether}("");
+        (ignoredSuccess);
 
         assertEq(address(coin).balance, 0, "coin balance");
     }
@@ -534,6 +523,7 @@ contract CoinTest is BaseTest {
         uint256 initialTokenCreatorBalance = protocolRewards.balanceOf(users.creator);
         uint256 initialOrderReferrerBalance = protocolRewards.balanceOf(users.tradeReferrer);
         uint256 initialFeeRecipientBalance = protocolRewards.balanceOf(users.feeRecipient);
+        uint256 initialDopplerRecipientBalance = airlock.owner().balance;
 
         uint256 buyAmount = 1 ether;
         vm.deal(users.buyer, buyAmount);
@@ -546,7 +536,11 @@ contract CoinTest is BaseTest {
         uint256 expectedLpFee = 9900000000000000; // 0.99 ETH * 1% --> ~0.00989 ETH
         MarketRewards memory marketRewards = _calculateMarketRewards(expectedLpFee);
 
-        assertEq(marketRewards.creator + marketRewards.platformReferrer + marketRewards.protocol, expectedLpFee, "Secondary rewards incorrect");
+        assertEq(
+            marketRewards.creator + marketRewards.platformReferrer + marketRewards.protocol + marketRewards.doppler,
+            expectedLpFee,
+            "Secondary rewards incorrect"
+        );
         assertApproxEqAbs(
             protocolRewards.balanceOf(users.creator),
             initialTokenCreatorBalance + orderFees.creator + marketRewards.creator,
@@ -559,6 +553,12 @@ contract CoinTest is BaseTest {
             0.0000000000000001 ether,
             "Platform referrer rewards incorrect"
         );
+        assertApproxEqAbs(
+            airlock.owner().balance,
+            initialDopplerRecipientBalance + marketRewards.doppler,
+            0.0000000000000001 ether,
+            "Doppler rewards incorrect"
+        );
         assertApproxEqAbs(
             protocolRewards.balanceOf(users.feeRecipient),
             initialFeeRecipientBalance + orderFees.protocol + marketRewards.protocol,