@zoralabs/coins 2.0.0 → 2.1.1

package/src/libs/CoinRewards.sol

@@ -1,201 +0,0 @@
-// SPDX-License-Identifier: ZORA-DELAYED-OSL-v1
-// This software is licensed under the Zora Delayed Open Source License.
-// Under this license, you may use, copy, modify, and distribute this software for
-// non-commercial purposes only. Commercial use and competitive products are prohibited
-// until the "Open Date" (3 years from first public distribution or earlier at Zora's discretion),
-// at which point this software automatically becomes available under the MIT License.
-// Full license terms available at: https://docs.zora.co/coins/license
-pragma solidity ^0.8.23;
-
-import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import {Address} from "@openzeppelin/contracts/utils/Address.sol";
-import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-import {IProtocolRewards} from "../interfaces/IProtocolRewards.sol";
-import {ICoin} from "../interfaces/ICoin.sol";
-import {CoinConstants} from "./CoinConstants.sol";
-import {IWETH} from "../interfaces/IWETH.sol";
-
-struct CoinConfig {
-    address protocolRewardRecipient;
-    address platformReferrer;
-    address payoutRecipient;
-    address protocolRewards;
-}
-
-library CoinRewards {
-    using SafeERC20 for IERC20;
-
-    /// @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, address currency, IWETH weth) internal {
-        address protocolRewardRecipient = coinConfig.protocolRewardRecipient;
-        address platformReferrer = coinConfig.platformReferrer;
-        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 == address(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 != address(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 calculateReward(uint256 amount, uint256 bps) internal pure returns (uint256) {
-        return (amount * bps) / 10_000;
-    }
-
-    function transferBothRewards(
-        address token0,
-        uint256 totalAmountToken0,
-        address token1,
-        uint256 totalAmountToken1,
-        address coin,
-        CoinConfig memory coinConfig,
-        address currency,
-        IWETH weth,
-        address doppler
-    ) internal returns (ICoin.MarketRewards memory rewards) {
-        rewards = transferMarketRewards(token0, currency, totalAmountToken0, rewards, coin, coinConfig, weth, doppler);
-        rewards = transferMarketRewards(token1, currency, totalAmountToken1, rewards, coin, coinConfig, weth, doppler);
-    }
-
-    struct Distribution {
-        bool isCurrency;
-        uint256 totalAmount;
-        uint256 creatorPayout;
-        uint256 platformReferrerPayout;
-        uint256 protocolPayout;
-    }
-
-    function transferMarketRewards(
-        address token,
-        address currency,
-        uint256 totalAmount,
-        ICoin.MarketRewards memory rewards,
-        address coin,
-        CoinConfig memory coinConfig,
-        IWETH weth,
-        address dopplerRecipient
-    ) internal returns (ICoin.MarketRewards memory) {
-        address payoutRecipient = coinConfig.payoutRecipient;
-        address platformReferrer = coinConfig.platformReferrer;
-        address protocolRewardRecipient = coinConfig.protocolRewardRecipient;
-        address protocolRewards = coinConfig.protocolRewards;
-
-        if (totalAmount > 0) {
-            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;
-
-            bool isCurrency = token == currency;
-
-            if (token == address(weth)) {
-                IWETH(weth).withdraw(totalAmount);
-
-                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] = creatorPayout;
-                amounts[1] = platformReferrerPayout;
-                amounts[2] = protocolPayout;
-                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 (!isCurrency) {
-                    IERC20(coin).safeTransfer(payoutRecipient, creatorPayout);
-                    IERC20(coin).safeTransfer(platformReferrer, platformReferrerPayout);
-                    IERC20(coin).safeTransfer(protocolRewardRecipient, protocolPayout);
-                    IERC20(coin).safeTransfer(dopplerRecipient, dopplerPayout);
-                } else {
-                    IERC20(currency).safeTransfer(payoutRecipient, creatorPayout);
-                    IERC20(currency).safeTransfer(platformReferrer, platformReferrerPayout);
-                    IERC20(currency).safeTransfer(protocolRewardRecipient, protocolPayout);
-                    IERC20(currency).safeTransfer(dopplerRecipient, dopplerPayout);
-                }
-            }
-
-            if (isCurrency) {
-                rewards.totalAmountCurrency = totalAmount;
-                rewards.creatorPayoutAmountCurrency = creatorPayout;
-                rewards.platformReferrerAmountCurrency = platformReferrerPayout;
-                rewards.protocolAmountCurrency = protocolPayout;
-            } else {
-                rewards.totalAmountCoin = totalAmount;
-                rewards.creatorPayoutAmountCoin = creatorPayout;
-                rewards.platformReferrerAmountCoin = platformReferrerPayout;
-                rewards.protocolAmountCoin = protocolPayout;
-            }
-        }
-
-        return rewards;
-    }
-}

package/src/libs/CoinSetupV3.sol

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

package/src/libs/UniV3BuySell.sol

@@ -1,231 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.23;
-
-import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-import {ISwapRouter} from "../interfaces/ISwapRouter.sol";
-import {IWETH} from "../interfaces/IWETH.sol";
-import {MarketConstants} from "./MarketConstants.sol";
-import {CoinConstants} from "./CoinConstants.sol";
-import {ICoin} from "../interfaces/ICoin.sol";
-import {IProtocolRewards} from "../interfaces/IProtocolRewards.sol";
-import {LpPosition} from "../types/LpPosition.sol";
-import {PoolConfiguration} from "../interfaces/ICoin.sol";
-import {IUniswapV3Pool} from "../interfaces/IUniswapV3Pool.sol";
-import {IAirlock} from "../interfaces/IAirlock.sol";
-import {CoinV3Config} from "./CoinSetupV3.sol";
-import {Address} from "@openzeppelin/contracts/utils/Address.sol";
-import {CoinDopplerUniV3} from "./CoinDopplerUniV3.sol";
-import {CoinConfigurationVersions} from "./CoinConfigurationVersions.sol";
-import {CoinRewards, CoinConfig} from "./CoinRewards.sol";
-struct SellResult {
-    uint256 payoutSize;
-    uint256 tradeReward;
-    uint256 trueOrderSize;
-}
-
-library UniV3BuySell {
-    using SafeERC20 for IERC20;
-
-    error AddressZero();
-    error InvalidPoolVersion();
-
-    function handleBuy(
-        address recipient,
-        uint256 orderSize,
-        uint256 minAmountOut,
-        uint160 sqrtPriceLimitX96,
-        address tradeReferrer,
-        CoinConfig memory coinConfig,
-        address currency,
-        ISwapRouter swapRouter,
-        IWETH weth
-    ) internal returns (uint256 amountOut, uint256 tradeReward, uint256 trueOrderSize) {
-        if (recipient == address(0)) {
-            revert AddressZero();
-        }
-
-        // Calculate the trade reward
-        tradeReward = _calculateReward(orderSize, CoinConstants.TOTAL_FEE_BPS);
-
-        // Calculate the remaining size
-        trueOrderSize = orderSize - tradeReward;
-
-        // Handle incoming currency
-        _handleIncomingCurrency(orderSize, trueOrderSize, currency, swapRouter, weth);
-
-        // Set up the swap parameters
-        ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({
-            tokenIn: currency,
-            tokenOut: address(this),
-            fee: MarketConstants.LP_FEE,
-            recipient: recipient,
-            amountIn: trueOrderSize,
-            amountOutMinimum: minAmountOut,
-            sqrtPriceLimitX96: sqrtPriceLimitX96
-        });
-
-        // Execute the swap
-        amountOut = ISwapRouter(swapRouter).exactInputSingle(params);
-
-        CoinRewards.handleTradeRewards(tradeReward, tradeReferrer, coinConfig, currency, weth);
-    }
-
-    function _executeSwap(
-        uint256 orderSize,
-        uint256 minAmountOut,
-        uint160 sqrtPriceLimitX96,
-        address currency,
-        ISwapRouter swapRouter
-    ) internal returns (uint256 amountOut) {
-        ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({
-            tokenIn: address(this),
-            tokenOut: currency,
-            fee: MarketConstants.LP_FEE,
-            recipient: address(this),
-            amountIn: orderSize,
-            amountOutMinimum: minAmountOut,
-            sqrtPriceLimitX96: sqrtPriceLimitX96
-        });
-
-        amountOut = swapRouter.exactInputSingle(params);
-    }
-
-    function _handleRefund(uint256 beforeCoinBalance, uint256 orderSize, address recipient) internal returns (uint256 trueOrderSize) {
-        uint256 afterCoinBalance = IERC20(address(this)).balanceOf(address(this));
-        trueOrderSize = orderSize;
-
-        if (afterCoinBalance > beforeCoinBalance) {
-            uint256 coinRefund = afterCoinBalance - beforeCoinBalance;
-            trueOrderSize -= coinRefund;
-            IERC20(address(this)).safeTransfer(recipient, coinRefund);
-        }
-    }
-
-    function _handlePayoutAndRewards(
-        uint256 amountOut,
-        address recipient,
-        address tradeReferrer,
-        CoinConfig memory coinConfig,
-        address currency,
-        IWETH weth
-    ) internal returns (uint256 payoutSize, uint256 tradeReward) {
-        if (currency == address(weth)) {
-            weth.withdraw(amountOut);
-        }
-
-        tradeReward = _calculateReward(amountOut, CoinConstants.TOTAL_FEE_BPS);
-        payoutSize = amountOut - tradeReward;
-
-        _handlePayout(payoutSize, recipient, currency, weth);
-
-        CoinRewards.handleTradeRewards(tradeReward, tradeReferrer, coinConfig, currency, weth);
-    }
-
-    function handleSell(
-        address recipient,
-        uint256 beforeCoinBalance,
-        uint256 orderSize,
-        uint256 minAmountOut,
-        uint160 sqrtPriceLimitX96,
-        address tradeReferrer,
-        CoinConfig memory coinConfig,
-        address currency,
-        ISwapRouter swapRouter,
-        IWETH weth
-    ) internal returns (SellResult memory result) {
-        if (recipient == address(0)) {
-            revert AddressZero();
-        }
-
-        uint256 amountOut = _executeSwap(orderSize, minAmountOut, sqrtPriceLimitX96, currency, swapRouter);
-        result.trueOrderSize = _handleRefund(beforeCoinBalance, orderSize, recipient);
-        (result.payoutSize, result.tradeReward) = _handlePayoutAndRewards(amountOut, recipient, tradeReferrer, coinConfig, currency, weth);
-    }
-
-    /// @dev Handles incoming currency transfers for buy orders; if WETH is the currency the caller has the option to send native-ETH
-    /// @param orderSize The total size of the order in the currency
-    /// @param trueOrderSize The actual amount being used for the swap after fees
-    function _handleIncomingCurrency(uint256 orderSize, uint256 trueOrderSize, address currency, ISwapRouter swapRouter, IWETH weth) internal {
-        if (currency == address(weth) && msg.value > 0) {
-            if (msg.value != orderSize) {
-                revert ICoin.EthAmountMismatch();
-            }
-
-            if (msg.value < CoinConstants.MIN_ORDER_SIZE) {
-                revert ICoin.EthAmountTooSmall();
-            }
-
-            IWETH(weth).deposit{value: trueOrderSize}();
-            IWETH(weth).approve(address(swapRouter), trueOrderSize);
-        } else {
-            // Ensure ETH is not sent with a non-ETH pair
-            if (msg.value != 0) {
-                revert ICoin.EthTransferInvalid();
-            }
-
-            uint256 beforeBalance = IERC20(currency).balanceOf(address(this));
-            IERC20(currency).safeTransferFrom(msg.sender, address(this), orderSize);
-            uint256 afterBalance = IERC20(currency).balanceOf(address(this));
-
-            if ((afterBalance - beforeBalance) != orderSize) {
-                revert ICoin.ERC20TransferAmountMismatch();
-            }
-
-            IERC20(currency).approve(address(swapRouter), trueOrderSize);
-        }
-    }
-
-    /// @dev Handles sending ETH and ERC20 payouts and refunds to recipients
-    /// @param orderPayout The amount of currency to pay out
-    /// @param recipient The address to receive the payout
-    function _handlePayout(uint256 orderPayout, address recipient, address currency, IWETH weth) internal {
-        if (currency == address(weth)) {
-            Address.sendValue(payable(recipient), orderPayout);
-        } else {
-            IERC20(currency).safeTransfer(recipient, orderPayout);
-        }
-    }
-
-    function _collectFees(LpPosition[] storage positions, address poolAddress) internal returns (uint256 totalAmountToken0, uint256 totalAmountToken1) {
-        for (uint256 i; i < positions.length; i++) {
-            // Must burn to update the collect mapping on the pool
-            IUniswapV3Pool(poolAddress).burn(positions[i].tickLower, positions[i].tickUpper, 0);
-
-            (uint256 amount0, uint256 amount1) = IUniswapV3Pool(poolAddress).collect(
-                address(this),
-                positions[i].tickLower,
-                positions[i].tickUpper,
-                type(uint128).max,
-                type(uint128).max
-            );
-
-            totalAmountToken0 += amount0;
-            totalAmountToken1 += amount1;
-        }
-    }
-
-    /// @dev Collects and distributes accrued fees from all LP positions
-    function handleMarketRewards(
-        CoinConfig memory coinConfig,
-        address currency,
-        address poolAddress,
-        LpPosition[] storage positions,
-        IWETH weth,
-        address doppler
-    ) internal returns (ICoin.MarketRewards memory rewards) {
-        address coin = address(this);
-        (uint256 totalAmountToken0, uint256 totalAmountToken1) = _collectFees(positions, poolAddress);
-
-        address token0 = currency < coin ? currency : coin;
-        address token1 = currency < coin ? coin : currency;
-
-        rewards = CoinRewards.transferBothRewards(token0, totalAmountToken0, token1, totalAmountToken1, coin, coinConfig, currency, weth, doppler);
-
-        emit ICoin.CoinMarketRewards(coinConfig.payoutRecipient, coinConfig.platformReferrer, coinConfig.protocolRewardRecipient, currency, rewards);
-    }
-
-    function _calculateReward(uint256 amount, uint256 bps) internal pure returns (uint256) {
-        return CoinRewards.calculateReward(amount, bps);
-    }
-}

package/src/libs/UniV3Errors.sol

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