@zoralabs/coins 0.9.0 → 1.0.1

package/src/Coin.sol

@@ -2,10 +2,7 @@
 pragma solidity ^0.8.23;
 
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 import {ICoin, PoolConfiguration} from "./interfaces/ICoin.sol";
-import {ICoinComments} from "./interfaces/ICoinComments.sol";
-import {IERC7572} from "./interfaces/IERC7572.sol";
 import {IUniswapV3Factory} from "./interfaces/IUniswapV3Factory.sol";
 import {IUniswapV3Pool} from "./interfaces/IUniswapV3Pool.sol";
 import {ISwapRouter} from "./interfaces/ISwapRouter.sol";
@@ -19,15 +16,14 @@ import {ReentrancyGuardUpgradeable} from "@openzeppelin/contracts-upgradeable/ut
 import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import {ContractVersionBase} from "./version/ContractVersionBase.sol";
 import {MultiOwnable} from "./utils/MultiOwnable.sol";
-import {FullMath} from "./utils/uniswap/FullMath.sol";
-import {TickMath} from "./utils/uniswap/TickMath.sol";
-import {LiquidityAmounts} from "./utils/uniswap/LiquidityAmounts.sol";
 import {CoinConstants} from "./libs/CoinConstants.sol";
 import {MarketConstants} from "./libs/MarketConstants.sol";
 import {LpPosition} from "./types/LpPosition.sol";
 import {PoolState} from "./types/PoolState.sol";
 import {CoinSetupV3, UniV3Config, CoinV3Config} from "./libs/CoinSetupV3.sol";
-import {UniV3BuySell, CoinConfig} from "./libs/UniV3BuySell.sol";
+import {UniV3BuySell, CoinConfig, SellResult} from "./libs/UniV3BuySell.sol";
+import {BaseCoin} from "./BaseCoin.sol";
+import {ICoinV3} from "./interfaces/ICoinV3.sol";
 
 /*
      $$$$$$\   $$$$$$\  $$$$$$\ $$\   $$\ 
@@ -39,183 +35,98 @@ import {UniV3BuySell, CoinConfig} from "./libs/UniV3BuySell.sol";
     \$$$$$$  | $$$$$$  |$$$$$$\ $$ | \$$ |
      \______/  \______/ \______|\__|  \__|
 */
-contract Coin is ICoin, ContractVersionBase, ERC20PermitUpgradeable, MultiOwnable, ReentrancyGuardUpgradeable {
+contract Coin is BaseCoin, ICoinV3 {
     using SafeERC20 for IERC20;
 
-    /// @notice The address of the WETH contract
-    address public immutable WETH;
-    /// @notice The address of the Uniswap V3 factory
     address public immutable v3Factory;
     /// @notice The address of the Uniswap V3 swap router
     address public immutable swapRouter;
-    /// @notice The address of the Airlock contract, ownership is used for a protocol fee split.
-    address public immutable airlock;
-    /// @notice The address of the protocol rewards contract
-    address public immutable protocolRewards;
-    /// @notice The address of the protocol reward recipient
-    address public immutable protocolRewardRecipient;
-
-    /// @notice The metadata URI
-    string public tokenURI;
-    /// @notice The address of the coin creator
-    address public payoutRecipient;
-    /// @notice The address of the platform referrer
-    address public platformReferrer;
     /// @notice The address of the Uniswap V3 pool
     address public poolAddress;
-    /// @notice The address of the currency
-    address public currency;
 
     /// @notice The state of the market
     bytes public market;
     uint8 public marketVersion;
 
+    /// @notice The address of the WETH contract
+    address public immutable WETH;
+
     /// @notice deprecated
     PoolConfiguration public poolConfiguration;
 
-    /// @notice Returns the state of the pool
-    /// @dev This is a legacy function for compatibility with doppler default state
-    /// @return asset The address of the asset
-    /// @return numeraire The address of the numeraire
-    /// @return tickLower The lower tick
-    /// @return tickUpper The upper tick
-    /// @return numPositions The number of discovery positions
-    /// @return isInitialized Whether the pool is initialized
-    /// @return isExited Whether the pool is exited
-    /// @return maxShareToBeSold The maximum share to be sold
-    /// @return totalTokensOnBondingCurve The total tokens on the bonding curve
-    function poolState()
-        external
-        view
-        returns (
-            address asset,
-            address numeraire,
-            int24 tickLower,
-            int24 tickUpper,
-            uint16 numPositions,
-            bool isInitialized,
-            bool isExited,
-            uint256 maxShareToBeSold,
-            uint256 totalTokensOnBondingCurve
-        )
-    {
-        asset = address(this);
-        numeraire = currency;
-        tickLower = poolConfiguration.tickLower;
-        tickUpper = poolConfiguration.tickUpper;
-        numPositions = poolConfiguration.numPositions;
-        isInitialized = true;
-        isExited = false;
-        maxShareToBeSold = poolConfiguration.maxDiscoverySupplyShare;
-        totalTokensOnBondingCurve = CoinConstants.POOL_LAUNCH_SUPPLY;
-    }
+    LpPosition[] public positions;
 
     /**
      * @notice The constructor for the static Coin contract deployment shared across all Coins.
-     * @param _protocolRewardRecipient The address of the protocol reward recipient
-     * @param _protocolRewards The address of the protocol rewards contract
-     * @param _weth The address of the WETH contract
-     * @param _v3Factory The address of the Uniswap V3 factory
-     * @param _swapRouter The address of the Uniswap V3 swap router
-     * @param _airlock The address of the Airlock contract, ownership is used for a protocol fee split.
+     * @param protocolRewardRecipient_ The address of the protocol reward recipient
+     * @param protocolRewards_ The address of the protocol rewards contract
+     * @param weth_ The address of the WETH contract
+     * @param v3Factory_ The address of the Uniswap V3 factory
+     * @param swapRouter_ The address of the Uniswap V3 swap router
+     * @param airlock_ The address of the Airlock contract, ownership is used for a protocol fee split.
      */
     constructor(
-        address _protocolRewardRecipient,
-        address _protocolRewards,
-        address _weth,
-        address _v3Factory,
-        address _swapRouter,
-        address _airlock
-    ) initializer {
-        if (_protocolRewardRecipient == address(0)) {
-            revert AddressZero();
-        }
-        if (_protocolRewards == address(0)) {
-            revert AddressZero();
-        }
-        if (_weth == address(0)) {
+        address protocolRewardRecipient_,
+        address protocolRewards_,
+        address weth_,
+        address v3Factory_,
+        address swapRouter_,
+        address airlock_
+    ) BaseCoin(protocolRewardRecipient_, protocolRewards_, airlock_) initializer {
+        if (v3Factory_ == address(0)) {
             revert AddressZero();
         }
-        if (_v3Factory == address(0)) {
+        if (swapRouter_ == address(0)) {
             revert AddressZero();
         }
-        if (_swapRouter == address(0)) {
+        if (airlock_ == address(0)) {
             revert AddressZero();
         }
-        if (_airlock == address(0)) {
+        if (weth_ == address(0)) {
             revert AddressZero();
         }
+        swapRouter = swapRouter_;
+        v3Factory = v3Factory_;
 
-        protocolRewardRecipient = _protocolRewardRecipient;
-        protocolRewards = _protocolRewards;
-        WETH = _weth;
-        swapRouter = _swapRouter;
-        v3Factory = _v3Factory;
-        airlock = _airlock;
+        WETH = weth_;
     }
 
-    /// @notice Initializes a new coin
-    /// @param payoutRecipient_ The address of the coin creator
-    /// @param tokenURI_ The metadata URI
-    /// @param name_ The coin name
-    /// @param symbol_ The coin symbol
-    /// @param poolConfig_ The parameters for the v3 pool and liquidity
-    /// @param platformReferrer_ The address of the platform referrer
+    /// @inheritdoc ICoinV3
     function initialize(
         address payoutRecipient_,
         address[] memory owners_,
         string memory tokenURI_,
         string memory name_,
         string memory symbol_,
-        bytes memory poolConfig_,
-        address platformReferrer_
+        address platformReferrer_,
+        address currency_,
+        address poolAddress_,
+        PoolConfiguration memory poolConfiguration_,
+        LpPosition[] memory positions_
     ) public initializer {
-        // Validate the creation parameters
-        if (payoutRecipient_ == address(0)) {
-            revert AddressZero();
-        }
-
-        // Set base contract state
-        __ERC20_init(name_, symbol_);
-        __ERC20Permit_init(name_);
-        __MultiOwnable_init(owners_);
-        __ReentrancyGuard_init();
-
-        // Set mutable state
-        _setPayoutRecipient(payoutRecipient_);
-        _setContractURI(tokenURI_);
+        super._initialize(payoutRecipient_, owners_, tokenURI_, name_, symbol_, platformReferrer_);
 
-        // Store the referrer if set
-        platformReferrer = platformReferrer_ == address(0) ? protocolRewardRecipient : platformReferrer_;
+        currency = currency_;
+        poolAddress = poolAddress_;
+        poolConfiguration = poolConfiguration_;
+        positions = positions_;
 
-        // Mint the total supply
-        _mint(address(this), CoinConstants.MAX_TOTAL_SUPPLY);
-
-        // Distribute the creator launch reward
-        _transfer(address(this), payoutRecipient, CoinConstants.CREATOR_LAUNCH_REWARD);
-
-        UniV3Config memory uniswapV3Config = UniV3Config({weth: WETH, v3Factory: v3Factory, swapRouter: swapRouter, airlock: airlock});
-
-        // Deploy the pool
-        (currency, poolAddress, poolConfiguration) = CoinSetupV3.setupPool(poolConfig_, uniswapV3Config, address(this));
-
-        // Split out the deployment of liquidity to avoid stack too deep
-        CoinSetupV3.deployLiquidity(address(this), currency, poolConfiguration, poolAddress);
+        CoinSetupV3.deployLiquidity(positions_, poolAddress);
     }
 
-    function buildCoinConfig() internal view returns (CoinConfig memory coinConfig) {
+    function buildConfig() internal view returns (CoinConfig memory coinConfig) {
         coinConfig = CoinConfig({
             protocolRewardRecipient: protocolRewardRecipient,
             platformReferrer: platformReferrer,
-            currency: currency,
             payoutRecipient: payoutRecipient,
-            protocolRewards: protocolRewards,
-            poolConfiguration: poolConfiguration,
-            poolAddress: poolAddress,
-            uniswapV3Config: UniV3Config({weth: WETH, v3Factory: v3Factory, swapRouter: swapRouter, airlock: airlock})
+            protocolRewards: protocolRewards
         });
     }
 
+    function getPoolConfiguration() public view returns (PoolConfiguration memory) {
+        return poolConfiguration;
+    }
+
     /// @notice Executes a buy order
     /// @param recipient The recipient address of the coins
     /// @param orderSize The amount of coins to buy
@@ -228,7 +139,24 @@ contract Coin is ICoin, ContractVersionBase, ERC20PermitUpgradeable, MultiOwnabl
         uint160 sqrtPriceLimitX96,
         address tradeReferrer
     ) public payable nonReentrant returns (uint256, uint256) {
-        return UniV3BuySell.buy(recipient, orderSize, minAmountOut, sqrtPriceLimitX96, tradeReferrer, address(this), buildCoinConfig());
+        CoinConfig memory coinConfig = buildConfig();
+        (uint256 amountOut, uint256 tradeReward, uint256 trueOrderSize) = UniV3BuySell.handleBuy(
+            recipient,
+            orderSize,
+            minAmountOut,
+            sqrtPriceLimitX96,
+            tradeReferrer,
+            coinConfig,
+            currency,
+            ISwapRouter(swapRouter),
+            IWETH(WETH)
+        );
+
+        UniV3BuySell.handleMarketRewards(coinConfig, currency, poolAddress, positions, IWETH(WETH), dopplerFeeRecipient());
+
+        emit CoinBuy(msg.sender, recipient, tradeReferrer, amountOut, currency, tradeReward, trueOrderSize);
+
+        return (orderSize, amountOut);
     }
 
     /// @notice Executes a sell order
@@ -253,21 +181,33 @@ contract Coin is ICoin, ContractVersionBase, ERC20PermitUpgradeable, MultiOwnabl
         // Approve the Uniswap V3 swap router
         this.approve(swapRouter, orderSize);
 
-        return UniV3BuySell.sell(recipient, beforeCoinBalance, orderSize, minAmountOut, sqrtPriceLimitX96, tradeReferrer, buildCoinConfig());
-    }
+        CoinConfig memory coinConfig = buildConfig();
+
+        SellResult memory result = UniV3BuySell.handleSell(
+            recipient,
+            beforeCoinBalance,
+            orderSize,
+            minAmountOut,
+            sqrtPriceLimitX96,
+            tradeReferrer,
+            coinConfig,
+            currency,
+            ISwapRouter(swapRouter),
+            IWETH(WETH)
+        );
+
+        UniV3BuySell.handleMarketRewards(coinConfig, currency, poolAddress, positions, IWETH(WETH), dopplerFeeRecipient());
+
+        emit ICoin.CoinSell(msg.sender, recipient, tradeReferrer, result.trueOrderSize, currency, result.tradeReward, result.payoutSize);
 
-    /// @notice Enables a user to burn their tokens
-    /// @param amount The amount of tokens to burn
-    function burn(uint256 amount) external {
-        // This burn function sets the from as msg.sender, so having an unauthed call is safe.
-        _burn(msg.sender, amount);
+        return (result.trueOrderSize, result.payoutSize);
     }
 
     /// @notice Force claim any accrued secondary rewards from the market's liquidity position.
     /// @dev This function is a fallback, secondary rewards will be claimed automatically on each buy and sell.
     /// @param pushEthRewards Whether to push the ETH directly to the recipients.
     function claimSecondaryRewards(bool pushEthRewards) external nonReentrant {
-        MarketRewards memory rewards = UniV3BuySell.handleMarketRewards(address(this), buildCoinConfig());
+        MarketRewards memory rewards = UniV3BuySell.handleMarketRewards(buildConfig(), currency, poolAddress, positions, IWETH(WETH), dopplerFeeRecipient());
 
         if (pushEthRewards && rewards.totalAmountCurrency > 0 && currency == WETH) {
             IProtocolRewards(protocolRewards).withdrawFor(payoutRecipient, rewards.creatorPayoutAmountCurrency);
@@ -276,38 +216,6 @@ contract Coin is ICoin, ContractVersionBase, ERC20PermitUpgradeable, MultiOwnabl
         }
     }
 
-    /// @notice Set the creator's payout address
-    /// @param newPayoutRecipient The new recipient address
-    function setPayoutRecipient(address newPayoutRecipient) external onlyOwner {
-        _setPayoutRecipient(newPayoutRecipient);
-    }
-
-    /// @notice Set the contract URI
-    /// @param newURI The new URI
-    function setContractURI(string memory newURI) external onlyOwner {
-        _setContractURI(newURI);
-    }
-
-    /// @notice The contract metadata
-    function contractURI() external view returns (string memory) {
-        return tokenURI;
-    }
-
-    /// @notice ERC165 interface support
-    /// @param interfaceId The interface ID to check
-    function supportsInterface(bytes4 interfaceId) public pure virtual returns (bool) {
-        return
-            interfaceId == type(ICoin).interfaceId ||
-            interfaceId == type(ICoinComments).interfaceId ||
-            interfaceId == type(IERC7572).interfaceId ||
-            interfaceId == type(IERC165).interfaceId;
-    }
-
-    /// @notice Receives ETH converted from WETH
-    receive() external payable {
-        require(msg.sender == WETH, OnlyWeth());
-    }
-
     /// @dev Called by the pool after minting liquidity to transfer the associated coins
     function uniswapV3MintCallback(uint256 amount0Owed, uint256 amount1Owed, bytes calldata) external {
         if (msg.sender != poolAddress) revert OnlyPool(msg.sender, poolAddress);
@@ -315,31 +223,8 @@ contract Coin is ICoin, ContractVersionBase, ERC20PermitUpgradeable, MultiOwnabl
         IERC20(address(this)).safeTransfer(poolAddress, amount0Owed == 0 ? amount1Owed : amount0Owed);
     }
 
-    /// @dev Overrides ERC20's _update function to emit a superset `CoinTransfer` event
-    function _update(address from, address to, uint256 value) internal virtual override {
-        super._update(from, to, value);
-
-        emit CoinTransfer(from, to, value, balanceOf(from), balanceOf(to));
-    }
-
-    /// @dev Used to set the payout recipient on coin creation and updates
-    /// @param newPayoutRecipient The new recipient address
-    function _setPayoutRecipient(address newPayoutRecipient) internal {
-        if (newPayoutRecipient == address(0)) {
-            revert AddressZero();
-        }
-
-        emit CoinPayoutRecipientUpdated(msg.sender, payoutRecipient, newPayoutRecipient);
-
-        payoutRecipient = newPayoutRecipient;
-    }
-
-    /// @dev Used to set the contract URI on coin creation and updates
-    /// @param newURI The new URI
-    function _setContractURI(string memory newURI) internal {
-        emit ContractMetadataUpdated(msg.sender, newURI, name());
-        emit ContractURIUpdated();
-
-        tokenURI = newURI;
+    /// @notice Receives ETH converted from WETH
+    receive() external payable {
+        require(msg.sender == WETH, OnlyWeth());
     }
 }

package/src/CoinV4.sol

@@ -0,0 +1,121 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {IPoolManager, PoolKey, Currency, IHooks} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+
+import {BaseCoin} from "./BaseCoin.sol";
+import {ICoinV4, IHasPoolKey, IHasSwapPath} from "./interfaces/ICoinV4.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {PoolConfiguration} from "./types/PoolConfiguration.sol";
+import {UniV4SwapToCurrency} from "./libs/UniV4SwapToCurrency.sol";
+import {PathKey} from "@uniswap/v4-periphery/src/libraries/PathKey.sol";
+import {IDeployedCoinVersionLookup} from "./interfaces/IDeployedCoinVersionLookup.sol";
+
+contract CoinV4 is BaseCoin, ICoinV4 {
+    /// @notice The Uniswap v4 pool manager singleton contract reference.
+    IPoolManager public immutable poolManager;
+
+    /// @notice The hooks contract used by this coin.
+    IHooks public immutable hooks;
+
+    /// @notice The pool key for the coin. Type from Uniswap V4 core.
+    PoolKey private poolKey;
+
+    /// @notice The configuration for the pool.
+    PoolConfiguration private poolConfiguration;
+
+    /// @notice The constructor for the static CoinV4 contract deployment shared across all Coins.
+    /// @dev All arguments are required and cannot be set to teh 0 address.
+    /// @param protocolRewardRecipient_ The address of the protocol reward recipient
+    /// @param protocolRewards_ The address of the protocol rewards contract
+    /// @param poolManager_ The address of the pool manager
+    /// @param airlock_ The address of the Airlock contract, ownership is used for a protocol fee split.
+    /// @param hooks_ The address of the hooks contract
+    /// @notice Returns the pool key for the coin
+    constructor(
+        address protocolRewardRecipient_,
+        address protocolRewards_,
+        IPoolManager poolManager_,
+        address airlock_,
+        IHooks hooks_
+    ) BaseCoin(protocolRewardRecipient_, protocolRewards_, airlock_) {
+        if (address(poolManager_) == address(0)) {
+            revert AddressZero();
+        }
+        if (address(hooks_) == address(0)) {
+            revert AddressZero();
+        }
+
+        poolManager = poolManager_;
+        hooks = hooks_;
+    }
+
+    /// @inheritdoc IHasPoolKey
+    function getPoolKey() public view returns (PoolKey memory) {
+        return poolKey;
+    }
+
+    /// @inheritdoc ICoinV4
+    function getPoolConfiguration() public view returns (PoolConfiguration memory) {
+        return poolConfiguration;
+    }
+
+    /// @inheritdoc ICoinV4
+    function initialize(
+        address payoutRecipient_,
+        address[] memory owners_,
+        string memory tokenURI_,
+        string memory name_,
+        string memory symbol_,
+        address platformReferrer_,
+        address currency_,
+        PoolKey memory poolKey_,
+        uint160 sqrtPriceX96,
+        PoolConfiguration memory poolConfiguration_
+    ) public initializer {
+        super._initialize(payoutRecipient_, owners_, tokenURI_, name_, symbol_, platformReferrer_);
+
+        currency = currency_;
+        poolKey = poolKey_;
+        poolConfiguration = poolConfiguration_;
+
+        // transfer the supply to the hook
+        _transfer(address(this), address(hooks), balanceOf(address(this)));
+        // initialize the pool - the hook will mint its positions in the afterInitialize callback
+        poolManager.initialize(poolKey, sqrtPriceX96);
+    }
+
+    function supportsInterface(bytes4 interfaceId) public pure virtual override(BaseCoin, IERC165) returns (bool) {
+        return interfaceId == type(IHasPoolKey).interfaceId || type(IHasSwapPath).interfaceId == interfaceId || super.supportsInterface(interfaceId);
+    }
+
+    /// @inheritdoc IHasSwapPath
+    function getPayoutSwapPath(IDeployedCoinVersionLookup coinVersionLookup) external view returns (IHasSwapPath.PayoutSwapPath memory payoutSwapPath) {
+        // if to swap in is this currency,
+        // if backing currency is a coin, then recursively get the path from the coin
+        payoutSwapPath.currencyIn = Currency.wrap(address(this));
+
+        // swap to backing currency
+        PathKey memory thisPathKey = PathKey({
+            intermediateCurrency: Currency.wrap(currency),
+            fee: poolKey.fee,
+            tickSpacing: poolKey.tickSpacing,
+            hooks: poolKey.hooks,
+            hookData: ""
+        });
+
+        // get backing currency swap path - if the backing currency is a v4 coin and has a swap path.
+        PathKey[] memory subPath = UniV4SwapToCurrency.getSubSwapPath(currency, coinVersionLookup);
+
+        if (subPath.length > 0) {
+            payoutSwapPath.path = new PathKey[](1 + subPath.length);
+            payoutSwapPath.path[0] = thisPathKey;
+            for (uint256 i = 0; i < subPath.length; i++) {
+                payoutSwapPath.path[i + 1] = subPath[i];
+            }
+        } else {
+            payoutSwapPath.path = new PathKey[](1);
+            payoutSwapPath.path[0] = thisPathKey;
+        }
+    }
+}