@zoralabs/coins 0.4.0 → 0.6.0

package/src/Coin.sol

@@ -138,7 +138,7 @@ contract Coin is ICoin, CoinConstants, ContractVersionBase, ERC20PermitUpgradeab
         uint256 minAmountOut,
         uint160 sqrtPriceLimitX96,
         address tradeReferrer
-    ) public payable nonReentrant returns (uint256) {
+    ) public payable nonReentrant returns (uint256, uint256) {
         // Ensure the recipient is not the zero address
         if (recipient == address(0)) {
             revert AddressZero();
@@ -173,7 +173,7 @@ contract Coin is ICoin, CoinConstants, ContractVersionBase, ERC20PermitUpgradeab
 
         emit CoinBuy(msg.sender, recipient, tradeReferrer, amountOut, currency, tradeReward, trueOrderSize);
 
-        return amountOut;
+        return (orderSize, amountOut);
     }
 
     /// @notice Executes a sell order
@@ -188,12 +188,15 @@ contract Coin is ICoin, CoinConstants, ContractVersionBase, ERC20PermitUpgradeab
         uint256 minAmountOut,
         uint160 sqrtPriceLimitX96,
         address tradeReferrer
-    ) public nonReentrant returns (uint256) {
+    ) public nonReentrant returns (uint256, uint256) {
         // Ensure the recipient is not the zero address
         if (recipient == address(0)) {
             revert AddressZero();
         }
 
+        // Record the coin balance of this contract before the swap
+        uint256 beforeCoinBalance = balanceOf(address(this));
+
         // Transfer the coins from the seller to this contract
         transfer(address(this), orderSize);
 
@@ -214,6 +217,21 @@ contract Coin is ICoin, CoinConstants, ContractVersionBase, ERC20PermitUpgradeab
         // Execute the swap
         uint256 amountOut = ISwapRouter(swapRouter).exactInputSingle(params);
 
+        // Record the coin balance of this contract after the swap
+        uint256 afterCoinBalance = balanceOf(address(this));
+
+        // If the swap was partially executed:
+        if (afterCoinBalance > beforeCoinBalance) {
+            // Calculate the refund
+            uint256 coinRefund = afterCoinBalance - beforeCoinBalance;
+
+            // Update the order size
+            orderSize -= coinRefund;
+
+            // Transfer the refund back to the seller
+            _transfer(address(this), recipient, coinRefund);
+        }
+
         // If currency is WETH, convert to ETH
         if (currency == WETH) {
             IWETH(WETH).withdraw(amountOut);
@@ -225,7 +243,7 @@ contract Coin is ICoin, CoinConstants, ContractVersionBase, ERC20PermitUpgradeab
         // Calculate the payout after the fee
         uint256 payoutSize = amountOut - tradeReward;
 
-        _handleSellPayout(payoutSize, recipient);
+        _handlePayout(payoutSize, recipient);
 
         _handleTradeRewards(tradeReward, tradeReferrer);
 
@@ -233,7 +251,7 @@ contract Coin is ICoin, CoinConstants, ContractVersionBase, ERC20PermitUpgradeab
 
         emit CoinSell(msg.sender, recipient, tradeReferrer, orderSize, currency, tradeReward, payoutSize);
 
-        return amountOut;
+        return (orderSize, payoutSize);
     }
 
     /// @notice Enables a user to burn their tokens
@@ -332,7 +350,7 @@ contract Coin is ICoin, CoinConstants, ContractVersionBase, ERC20PermitUpgradeab
     /// @dev Deploy the pool
     function _deployPool(int24 tickLower_) internal {
         // If WETH is the pool's currency, validate the lower tick
-        if (currency == WETH && tickLower_ != LP_TICK_LOWER_WETH) {
+        if (currency == WETH && tickLower_ < LP_TICK_LOWER_WETH) {
             revert InvalidWethLowerTick();
         }
 
@@ -415,10 +433,10 @@ contract Coin is ICoin, CoinConstants, ContractVersionBase, ERC20PermitUpgradeab
         }
     }
 
-    /// @dev Handles sending ETH and ERC20 payouts from sell orders to recipients
+    /// @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 _handleSellPayout(uint256 orderPayout, address recipient) internal {
+    function _handlePayout(uint256 orderPayout, address recipient) internal {
         if (currency == WETH) {
             Address.sendValue(payable(recipient), orderPayout);
         } else {

package/src/ZoraFactoryImpl.sol

@@ -102,9 +102,9 @@ contract ZoraFactoryImpl is IZoraFactory, UUPSUpgradeable, ReentrancyGuardUpgrad
 
                 IERC20(currency).approve(address(coin), orderSize);
 
-                coinsPurchased = coin.buy(payoutRecipient, orderSize, 0, 0, address(0));
+                (, coinsPurchased) = coin.buy(payoutRecipient, orderSize, 0, 0, address(0));
             } else {
-                coinsPurchased = coin.buy{value: msg.value}(payoutRecipient, orderSize, 0, 0, address(0));
+                (, coinsPurchased) = coin.buy{value: msg.value}(payoutRecipient, orderSize, 0, 0, address(0));
             }
         }
     }

package/src/interfaces/ICoin.sol

@@ -172,7 +172,7 @@ interface ICoin is IERC165, IERC721Receiver, IERC7572 {
         uint256 minAmountOut,
         uint160 sqrtPriceLimitX96,
         address tradeReferrer
-    ) external payable returns (uint256);
+    ) external payable returns (uint256, uint256);
 
     /// @notice Executes a sell order
     /// @param recipient The recipient of the currency
@@ -180,7 +180,13 @@ interface ICoin is IERC165, IERC721Receiver, IERC7572 {
     /// @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 orderSize, uint256 minAmountOut, uint160 sqrtPriceLimitX96, address tradeReferrer) external returns (uint256);
+    function sell(
+        address recipient,
+        uint256 orderSize,
+        uint256 minAmountOut,
+        uint160 sqrtPriceLimitX96,
+        address tradeReferrer
+    ) external returns (uint256, uint256);
 
     /// @notice Enables a user to burn their tokens
     /// @param amount The amount of tokens to burn

package/src/proxy/ZoraFactory.sol

@@ -22,5 +22,11 @@ import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.s
                OURS TRULY,
 */
 contract ZoraFactory is ERC1967Proxy {
-    constructor(address _logic, bytes memory _data) ERC1967Proxy(_logic, _data) {}
+    bytes32 internal immutable name;
+
+    constructor(address _logic) ERC1967Proxy(_logic, "") {
+        // added to create unique bytecode for this contract
+        // so that it can be properly verified as its own contract.
+        name = keccak256("ZoraFactory");
+    }
 }

package/src/utils/CoinConstants.sol

@@ -50,9 +50,9 @@ abstract contract CoinConstants {
     /// @dev 10000 basis points = 1%
     uint24 internal constant LP_FEE = 10000;
 
-    /// @notice The LP's lower tick
+    /// @notice The LP's minimum lower tick
     /// @dev This is only used if the currency is WETH
-    int24 internal constant LP_TICK_LOWER_WETH = -199200;
+    int24 internal constant LP_TICK_LOWER_WETH = -208200;
 
     /// @notice The LP's upper tick
     int24 internal constant LP_TICK_UPPER = 887200;

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.4.0";
+        return "0.6.0";
     }
 }

package/test/Coin.t.sol

@@ -2,6 +2,7 @@
 pragma solidity ^0.8.13;
 
 import "./utils/BaseTest.sol";
+import {ISwapRouter} from "../src/interfaces/ISwapRouter.sol";
 
 contract CoinTest is BaseTest {
     function setUp() public override {
@@ -10,6 +11,10 @@ contract CoinTest is BaseTest {
         _deployCoin();
     }
 
+    function test_contract_version() public view {
+        assertEq(coin.contractVersion(), "0.6.0");
+    }
+
     function test_supply_constants() public view {
         assertEq(MAX_TOTAL_SUPPLY, POOL_LAUNCH_SUPPLY + CREATOR_LAUNCH_REWARD);
 
@@ -183,6 +188,94 @@ contract CoinTest is BaseTest {
         coin.buy(users.coinRecipient, 100e6, 0, 0, users.tradeReferrer);
     }
 
+    function test_buy_validate_return_amounts(uint256 orderSize) public {
+        vm.assume(orderSize >= MIN_ORDER_SIZE);
+        vm.assume(orderSize < 10 ether);
+
+        vm.deal(users.buyer, orderSize);
+        vm.prank(users.buyer);
+        (uint256 amountIn, uint256 amountOut) = coin.buy{value: orderSize}(users.coinRecipient, orderSize, 0, 0, users.tradeReferrer);
+
+        assertEq(amountIn, orderSize, "amountIn");
+        assertGe(coin.balanceOf(users.coinRecipient), amountOut, "coinRecipient coin balance");
+    }
+
+    function test_sell_for_eth_direct_and_claim_secondary() public {
+        vm.deal(users.buyer, 1 ether);
+
+        vm.prank(users.buyer);
+        weth.deposit{value: 100_000}();
+
+        vm.prank(users.buyer);
+        weth.approve(address(swapRouter), 100_000);
+
+        // Set up the swap parameters
+        ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({
+            tokenIn: WETH_ADDRESS,
+            tokenOut: address(coin),
+            fee: LP_FEE,
+            recipient: address(users.buyer),
+            amountIn: 100_000,
+            amountOutMinimum: 0,
+            sqrtPriceLimitX96: 0
+        });
+
+        // Execute the swap
+        vm.prank(users.buyer);
+        uint256 amountOut = ISwapRouter(swapRouter).exactInputSingle(params);
+
+        assertEq(coin.balanceOf(users.buyer), 108941722423358, "buyer coin balance");
+        assertEq(amountOut, 108941722423358);
+        assertGt(users.buyer.balance, 0, "seller eth balance");
+
+        // now we have unclaimed secondary rewards to claim
+        vm.prank(users.buyer);
+
+        // don't push ETH
+        coin.claimSecondaryRewards(false);
+        assertEq(protocolRewards.balanceOf(users.creator), 499);
+        assertEq(protocolRewards.balanceOf(users.platformReferrer), 249);
+        assertEq(protocolRewards.balanceOf(users.feeRecipient), 251);
+    }
+
+    function test_sell_for_eth_direct_and_claim_secondary_push_eth() public {
+        vm.deal(users.buyer, 1 ether);
+
+        vm.prank(users.buyer);
+        weth.deposit{value: 100_000}();
+
+        vm.prank(users.buyer);
+        weth.approve(address(swapRouter), 100_000);
+
+        // Set up the swap parameters
+        ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({
+            tokenIn: WETH_ADDRESS,
+            tokenOut: address(coin),
+            fee: LP_FEE,
+            recipient: address(users.buyer),
+            amountIn: 100_000,
+            amountOutMinimum: 0,
+            sqrtPriceLimitX96: 0
+        });
+
+        // Execute the swap
+        vm.prank(users.buyer);
+        uint256 amountOut = ISwapRouter(swapRouter).exactInputSingle(params);
+
+        assertEq(coin.balanceOf(users.buyer), 108941722423358, "buyer coin balance");
+        assertEq(amountOut, 108941722423358);
+        assertGt(users.buyer.balance, 0, "seller eth balance");
+
+        // Now we have unclaimed secondary rewards to claim
+        vm.prank(users.buyer);
+
+        uint256 initialBalance = users.creator.balance;
+
+        // Push ETH
+        coin.claimSecondaryRewards(true);
+        assertEq(users.creator.balance - initialBalance, 499);
+    }
+
     function test_sell_for_eth() public {
         vm.deal(users.buyer, 1 ether);
         vm.prank(users.buyer);
@@ -262,6 +355,27 @@ contract CoinTest is BaseTest {
         coin.sell(users.coinRecipient, balance + 1, 0, 0, users.tradeReferrer);
     }
 
+    function test_sell_partial_execution() public {
+        vm.deal(users.creator, 1 ether);
+        vm.prank(users.creator);
+        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
+
+        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)
+
+        uint256 afterBalance = coin.balanceOf(users.creator);
+        assertEq(afterBalance, 9994558841570544323195890); // 9,994,559 coins
+
+        uint256 expectedMarketReward = 5441158429455676804107; // 5,441 coins
+
+        // 9,994,559 = 11,077,349 order size - 1,088,232 true order size + 5,441 creator market reward
+        assertEq(afterBalance, ((beforeBalance - amountSold) + expectedMarketReward), "amountSold");
+    }
+
     function test_burn() public {
         vm.deal(users.buyer, 1 ether);
         vm.prank(users.buyer);
@@ -324,6 +438,42 @@ 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);
@@ -459,8 +609,4 @@ contract CoinTest is BaseTest {
         vm.expectRevert(abi.encodeWithSelector(MultiOwnable.OnlyOwner.selector));
         coin.setPayoutRecipient(newPayoutRecipient);
     }
-
-    function test_contract_version() public view {
-        assertEq(coin.contractVersion(), "0.4.0");
-    }
 }

package/test/Factory.t.sol

@@ -96,6 +96,35 @@ contract FactoryTest is BaseTest {
         console.log("BUYER_COIN_BALANCE ", coin.balanceOf(users.creator) - 10_000_000e18);
     }
 
+    function test_deploy_with_weth(uint256 initialOrderSize) public {
+        vm.assume(initialOrderSize > MIN_ORDER_SIZE);
+        vm.assume(initialOrderSize < 10 ether);
+
+        address[] memory owners = new address[](1);
+        owners[0] = users.creator;
+
+        vm.deal(users.creator, initialOrderSize);
+
+        vm.startPrank(users.creator);
+        weth.deposit{value: initialOrderSize}();
+
+        weth.approve(address(factory), type(uint256).max);
+
+        // Expect this to revert because WETH needs to be sent with msg.value.
+        vm.expectRevert();
+        factory.deploy(
+            users.creator,
+            owners,
+            "https://test2.com",
+            "Test2 Token",
+            "TEST2",
+            users.platformReferrer,
+            address(weth),
+            LP_TICK_LOWER_WETH,
+            initialOrderSize
+        );
+    }
+
     function test_deploy_with_one_eth() public {
         address[] memory owners = new address[](1);
         owners[0] = users.creator;
@@ -206,17 +235,7 @@ contract FactoryTest is BaseTest {
 
         vm.expectRevert(abi.encodeWithSelector(ICoin.InvalidWethLowerTick.selector));
 
-        factory.deploy(
-            users.creator,
-            owners,
-            "https://testcoinusdcpair.com",
-            "Testcoinusdcpair",
-            "TESTCOINUSDCPAIR",
-            users.platformReferrer,
-            address(0),
-            USDC_TICK_LOWER,
-            0
-        );
+        factory.deploy(users.creator, owners, "https://testcoin.com", "Testcoin", "TESTCOIN", users.platformReferrer, address(0), LP_TICK_LOWER_WETH - 1, 0);
     }
 
     function test_deploy_with_usdc_revert_invalid_eth_transfer() public {
@@ -272,6 +291,10 @@ contract FactoryTest is BaseTest {
         assertEq(factory.implementation(), address(newImpl), "implementation");
     }
 
+    function test_implementation_address() public view {
+        assertEq(factory.implementation(), address(factoryImpl));
+    }
+
     function test_revert_invalid_upgrade_impl() public {
         address newImpl = address(this);
 

package/test/utils/BaseTest.sol

@@ -59,7 +59,7 @@ contract BaseTest is Test, CoinConstants {
     IUniswapV3Pool internal pool;
 
     function setUp() public virtual {
-        forkId = vm.createSelectFork("https://mainnet.base.org", 21179722);
+        forkId = vm.createSelectFork("base", 21179722);
 
         weth = IWETH(WETH_ADDRESS);
         usdc = IERC20Metadata(USDC_ADDRESS);
@@ -80,9 +80,9 @@ contract BaseTest is Test, CoinConstants {
 
         coinImpl = new Coin(users.feeRecipient, address(protocolRewards), WETH_ADDRESS, NONFUNGIBLE_POSITION_MANAGER, SWAP_ROUTER);
         factoryImpl = new ZoraFactoryImpl(address(coinImpl));
-        factory = ZoraFactoryImpl(
-            address(new ZoraFactory(address(factoryImpl), abi.encodeWithSelector(ZoraFactoryImpl.initialize.selector, users.factoryOwner)))
-        );
+        factory = ZoraFactoryImpl(address(new ZoraFactory(address(factoryImpl))));
+
+        ZoraFactoryImpl(factory).initialize(users.factoryOwner);
 
         vm.label(address(factory), "ZORA_FACTORY");
         vm.label(address(protocolRewards), "PROTOCOL_REWARDS");

package/abis/Deploy.json

@@ -1,29 +0,0 @@
-[
-  {
-    "type": "function",
-    "name": "IS_SCRIPT",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "run",
-    "inputs": [],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "setUp",
-    "inputs": [],
-    "outputs": [],
-    "stateMutability": "nonpayable"
-  }
-]

package/addresses/1.json

@@ -1,4 +0,0 @@
-{
-    "WETH": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
-    "UniswapQuoter": "0x61fFE014bA17989E743c5F6cB21bF9697530B21e"
-}