@zoralabs/coins 0.9.0 → 1.0.1

package/src/libs/CoinSetupV3.sol

@@ -2,14 +2,14 @@
 pragma solidity ^0.8.23;
 
 import {PoolConfiguration} from "../interfaces/ICoin.sol";
-import {CoinLegacy} from "./CoinLegacy.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;
@@ -24,75 +24,12 @@ struct CoinV3Config {
 }
 
 library CoinSetupV3 {
-    error InvalidPoolVersion();
-
-    function setupPool(
-        bytes memory poolConfig_,
-        UniV3Config memory uniswapV3Config,
-        address coin
-    ) internal returns (address currency, address poolAddress, PoolConfiguration memory poolConfiguration) {
-        // Extract version and currency from pool config
-        (uint8 version, address currency_) = abi.decode(poolConfig_, (uint8, address));
-
-        // Store the currency, defaulting to WETH if address(0)
-        currency = currency_ == address(0) ? uniswapV3Config.weth : currency_;
-
-        // Sort token addresses for Uniswap V3 pool creation
-        bool isCoinToken0 = _sortTokens(coin, currency);
-        address token0 = isCoinToken0 ? coin : currency;
-        address token1 = isCoinToken0 ? currency : coin;
-
-        // Configure the pool with appropriate version
-        uint160 sqrtPriceX96;
-        (sqrtPriceX96, poolConfiguration) = setupPoolWithVersion(version, poolConfig_, isCoinToken0, uniswapV3Config.weth);
-
-        // Create the pool
-        poolAddress = _createPool(token0, token1, sqrtPriceX96, uniswapV3Config.v3Factory);
-    }
-
     /// @dev Deploys the Uniswap V3 pool and mints initial liquidity based on the pool configuration
-    function deployLiquidity(address coin, address currency, PoolConfiguration memory poolConfiguration, address poolAddress) internal {
+    function deployLiquidity(LpPosition[] memory positions, address poolAddress) internal {
         // Calculate and mint positions
-        LpPosition[] memory positions = calculatePositions(coin, currency, poolConfiguration);
         _mintPositions(positions, poolAddress);
     }
 
-    // Helper function to sort tokens and determine if coin is token0
-    function _sortTokens(address coin, address currency) private pure returns (bool isCoinToken0) {
-        return coin < currency;
-    }
-
-    function setupPoolWithVersion(
-        uint8 version,
-        bytes memory poolConfig_,
-        bool isCoinToken0,
-        address weth
-    ) internal pure returns (uint160 sqrtPriceX96, PoolConfiguration memory poolConfiguration) {
-        if (version == CoinConfigurationVersions.LEGACY_POOL_VERSION) {
-            (sqrtPriceX96, poolConfiguration) = CoinLegacy.setupPool(isCoinToken0, poolConfig_, weth);
-        } else if (version == CoinConfigurationVersions.DOPPLER_UNI_V3_POOL_VERSION) {
-            (sqrtPriceX96, poolConfiguration) = CoinDopplerUniV3.setupPool(isCoinToken0, poolConfig_);
-        } else {
-            revert InvalidPoolVersion();
-        }
-    }
-
-    function calculatePositions(
-        address coin,
-        address currency,
-        PoolConfiguration memory poolConfiguration
-    ) internal pure returns (LpPosition[] memory positions) {
-        // Create the pool
-        bool isCoinToken0 = _sortTokens(coin, currency);
-        if (poolConfiguration.version == CoinConfigurationVersions.LEGACY_POOL_VERSION) {
-            positions = CoinLegacy.calculatePositions(isCoinToken0, poolConfiguration.tickLower, poolConfiguration.tickUpper);
-        } else if (poolConfiguration.version == CoinConfigurationVersions.DOPPLER_UNI_V3_POOL_VERSION) {
-            positions = CoinDopplerUniV3.calculatePositions(isCoinToken0, poolConfiguration);
-        } else {
-            revert InvalidPoolVersion();
-        }
-    }
-
     /// @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++) {
@@ -101,7 +38,9 @@ library CoinSetupV3 {
     }
 
     /// @dev Creates the Uniswap V3 pool for the coin/currency pair
-    function _createPool(address token0, address token1, uint160 sqrtPriceX96, address v3Factory) internal returns (address pool) {
+    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

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,128 @@
+// 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;
+
+    function deterministicHookAddress(address deployer, bytes32 salt, bytes memory creationCode) internal view returns (address) {
+        return Create2.computeAddress(salt, keccak256(creationCode), deployer);
+    }
+
+    /// @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 = deterministicHookAddress(deployer, bytes32(salt), creationCodeWithArgs);
+
+            // 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 mineForSaltAndDeployHook(address deployer, bytes memory hookCreationCode) internal returns (IHooks hook, bytes32 salt) {
+        uint160 flags = uint160(Hooks.AFTER_SWAP_FLAG | Hooks.AFTER_INITIALIZE_FLAG) ^ (0x4444 << 144);
+
+        address hookAddress;
+        (hookAddress, salt) = HookMinerWithCreationCodeArgs.find(deployer, flags, hookCreationCode);
+
+        // check if the hook is already deployed
+        (bool isDeployed, address existingHookAddress) = hooksIsDeployed(deployer, hookCreationCode, salt);
+        if (isDeployed) {
+            return (IHooks(existingHookAddress), salt);
+        }
+
+        hook = IHooks(Create2.deploy(0, salt, hookCreationCode));
+
+        require(address(hook).code.length > 0, HookNotDeployed());
+
+        require(hookAddress == address(hook), InvalidHookAddress(hookAddress, address(hook)));
+    }
+
+    /// @notice Checks if ZoraV4CoinHook is already deployed for given parameters
+    /// @param deployer The address that will deploy the hook
+    /// @param hookCreationCode The creation code of the hook
+    /// @param existingSalt The salt of the existing hook
+    /// @return isDeployed True if hook is already deployed
+    /// @return hookAddress The address where the hook would be/is deployed
+    function hooksIsDeployed(
+        address deployer,
+        bytes memory hookCreationCode,
+        bytes32 existingSalt
+    ) internal view returns (bool isDeployed, address hookAddress) {
+        hookAddress = HookMinerWithCreationCodeArgs.deterministicHookAddress(deployer, existingSalt, hookCreationCode);
+
+        // Check if code exists at the predicted address
+        isDeployed = hookAddress.code.length > 0;
+    }
+
+    function deployOrGetHook(address deployer, bytes memory hookCreationCode, bytes32 existingSalt) internal returns (IHooks hook, bytes32 salt) {
+        (bool isDeployed, address existingHookAddress) = hooksIsDeployed(deployer, hookCreationCode, existingSalt);
+        if (isDeployed) {
+            return (IHooks(existingHookAddress), existingSalt);
+        }
+
+        (hook, salt) = mineForSaltAndDeployHook(deployer, hookCreationCode);
+    }
+
+    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) {
+        bytes memory hookCreationCode = zoraV4CoinHookCreationCode(poolManager, coinVersionLookup, trustedMessageSenders);
+        (hook, ) = deployOrGetHook(address(this), hookCreationCode, bytes32(0));
+    }
+
+    /// @notice Deploys or returns existing ZoraV4CoinHook using deterministic deployment.  Ensures that if a hooks is already
+    /// deployed with an existing salt, it will be returned.
+    function deployZoraV4CoinHookFromScript(
+        address poolManager,
+        address coinVersionLookup,
+        address[] memory trustedMessageSenders,
+        bytes32 existingSalt
+    ) internal returns (IHooks hook, bytes32 salt) {
+        address deployer = 0x4e59b44847b379578588920cA78FbF26c0B4956C;
+
+        bytes memory hookCreationCode = zoraV4CoinHookCreationCode(poolManager, coinVersionLookup, trustedMessageSenders);
+
+        (hook, salt) = deployOrGetHook(deployer, hookCreationCode, existingSalt);
+    }
+}

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