@zoralabs/coins 0.1.1

package/test/Factory.t.sol

@@ -0,0 +1,298 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import "./utils/BaseTest.sol";
+
+contract FactoryTest is BaseTest {
+    function setUp() public override {
+        super.setUp();
+    }
+
+    function test_constructor() public view {
+        assertEq(factory.coinImpl(), address(coinImpl));
+        assertEq(factory.owner(), users.factoryOwner);
+    }
+
+    function test_deploy_no_eth() public {
+        address[] memory owners = new address[](1);
+        owners[0] = users.creator;
+
+        vm.prank(users.creator);
+        coin = Coin(
+            payable(
+                factory.deploy(users.creator, owners, "https://test2.com", "Test2 Token", "TEST2", users.platformReferrer, address(weth), LP_TICK_LOWER_WETH, 0)
+            )
+        );
+        pool = IUniswapV3Pool(coin.poolAddress());
+        vm.label(address(coin), "COIN");
+        vm.label(address(pool), "POOL");
+
+        uint160 sqrtPriceX96 = pool.slot0().sqrtPriceX96;
+        uint256 poolCoinBalance = coin.balanceOf(address(pool));
+        uint256 poolEthBalance = weth.balanceOf(address(pool));
+
+        console.log("POOL_TOKEN_0: ", pool.token0());
+        console.log("POOL_TOKEN_1: ", pool.token1());
+        console.log("POOL_SQRT_PRICE_X96: ", sqrtPriceX96);
+        console.log("");
+        console.log("POOL_COIN_BALANCE: ", poolCoinBalance);
+        console.log("POOL_ETH_BALANCE: ", poolEthBalance);
+        console.log("");
+
+        assertEq(coin.payoutRecipient(), users.creator, "payoutRecipient");
+        assertEq(coin.protocolRewardRecipient(), users.feeRecipient, "protocolRewardRecipient");
+        assertEq(coin.platformReferrer(), users.platformReferrer, "platformReferrer");
+        assertEq(coin.tokenURI(), "https://test2.com", "tokenURI");
+        assertEq(coin.name(), "Test2 Token", "name");
+        assertEq(coin.symbol(), "TEST2", "symbol");
+        assertEq(coin.currency(), address(weth), "currency");
+        assertEq(coin.totalSupply(), 1_000_000_000e18, "totalSupply");
+        assertEq(coin.balanceOf(users.creator), 10_000_000e18, "balanceOf creator");
+        assertGe(coin.balanceOf(users.platformReferrer), 5_000_000e18, "balanceOf platformReferrer");
+        assertGe(coin.balanceOf(users.feeRecipient), 5_000_000e18, "balanceOf protocolRewardRecipient");
+        assertGt(coin.balanceOf(coin.poolAddress()), 979_999_983e18, "balanceOf pool");
+    }
+
+    function test_deploy_with_eth(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.prank(users.creator);
+        coin = Coin(
+            payable(
+                factory.deploy{value: initialOrderSize}(
+                    users.creator,
+                    owners,
+                    "https://test2.com",
+                    "Test2 Token",
+                    "TEST2",
+                    users.platformReferrer,
+                    address(weth),
+                    LP_TICK_LOWER_WETH,
+                    initialOrderSize
+                )
+            )
+        );
+        pool = IUniswapV3Pool(coin.poolAddress());
+        vm.label(address(coin), "COIN");
+        vm.label(address(pool), "POOL");
+
+        uint160 sqrtPriceX96 = pool.slot0().sqrtPriceX96;
+        uint256 poolCoinBalance = coin.balanceOf(address(pool));
+        uint256 poolEthBalance = weth.balanceOf(address(pool));
+
+        console.log("POOL_TOKEN_0: ", pool.token0());
+        console.log("POOL_TOKEN_1: ", pool.token1());
+        console.log("POOL_SQRT_PRICE_X96: ", sqrtPriceX96);
+        console.log("");
+        console.log("POOL_COIN_BALANCE: ", poolCoinBalance);
+        console.log("POOL_ETH_BALANCE: ", poolEthBalance);
+        console.log("");
+        console.log("BUYER_COIN_BALANCE ", coin.balanceOf(users.creator) - 10_000_000e18);
+    }
+
+    function test_deploy_with_one_eth() public {
+        address[] memory owners = new address[](1);
+        owners[0] = users.creator;
+
+        uint256 orderSize = 1 ether;
+        vm.deal(users.creator, orderSize);
+
+        vm.prank(users.creator);
+        coin = Coin(
+            payable(
+                factory.deploy{value: orderSize}(
+                    users.creator,
+                    owners,
+                    "https://test2.com",
+                    "Test2 Token",
+                    "TEST2",
+                    users.platformReferrer,
+                    address(weth),
+                    LP_TICK_LOWER_WETH,
+                    orderSize
+                )
+            )
+        );
+        pool = IUniswapV3Pool(coin.poolAddress());
+        vm.label(address(coin), "COIN");
+        vm.label(address(pool), "POOL");
+    }
+
+    function test_deploy_with_usdc() public {
+        address[] memory owners = new address[](1);
+        owners[0] = users.creator;
+
+        vm.prank(users.creator);
+        coin = Coin(
+            payable(
+                factory.deploy(
+                    users.creator,
+                    owners,
+                    "https://testcoinusdcpair.com",
+                    "Testcoinusdcpair",
+                    "TESTCOINUSDCPAIR",
+                    users.platformReferrer,
+                    USDC_ADDRESS,
+                    USDC_TICK_LOWER,
+                    0
+                )
+            )
+        );
+        pool = IUniswapV3Pool(coin.poolAddress());
+        vm.label(address(coin), "COIN");
+        vm.label(address(pool), "POOL");
+
+        assertEq(coin.currency(), USDC_ADDRESS, "currency");
+        assertEq(coin.payoutRecipient(), users.creator, "payoutRecipient");
+    }
+
+    function test_deploy_with_usdc_revert_payout_recipient_zero() public {
+        address[] memory owners = new address[](1);
+        owners[0] = users.creator;
+
+        vm.expectRevert(abi.encodeWithSelector(ICoin.AddressZero.selector));
+        factory.deploy(
+            address(0),
+            owners,
+            "https://testcoinusdcpair.com",
+            "Testcoinusdcpair",
+            "TESTCOINUSDCPAIR",
+            users.platformReferrer,
+            USDC_ADDRESS,
+            USDC_TICK_LOWER,
+            0
+        );
+    }
+
+    function test_deploy_with_usdc_revert_one_owner_required() public {
+        address[] memory owners = new address[](0);
+
+        vm.expectRevert(abi.encodeWithSelector(MultiOwnable.OneOwnerRequired.selector));
+        factory.deploy(
+            users.creator,
+            owners,
+            "https://testcoinusdcpair.com",
+            "Testcoinusdcpair",
+            "TESTCOINUSDCPAIR",
+            users.platformReferrer,
+            USDC_ADDRESS,
+            USDC_TICK_LOWER,
+            0
+        );
+    }
+
+    function test_deploy_with_usdc_platform_referrer_zero() public {
+        address[] memory owners = new address[](1);
+        owners[0] = users.creator;
+
+        coin = Coin(
+            payable(
+                factory.deploy(
+                    users.creator,
+                    owners,
+                    "https://testcoinusdcpair.com",
+                    "Testcoinusdcpair",
+                    "TESTCOINUSDCPAIR",
+                    address(0),
+                    USDC_ADDRESS,
+                    USDC_TICK_LOWER,
+                    0
+                )
+            )
+        );
+
+        assertEq(coin.platformReferrer(), coin.protocolRewardRecipient(), "platformReferrer");
+    }
+
+    function test_revert_deploy_with_invalid_currency_tick() public {
+        address[] memory owners = new address[](1);
+        owners[0] = users.creator;
+
+        vm.expectRevert(abi.encodeWithSelector(ICoin.InvalidWethLowerTick.selector));
+        coin = Coin(
+            payable(
+                factory.deploy(
+                    users.creator,
+                    owners,
+                    "https://testcoinusdcpair.com",
+                    "Testcoinusdcpair",
+                    "TESTCOINUSDCPAIR",
+                    users.platformReferrer,
+                    address(0),
+                    USDC_TICK_LOWER,
+                    0
+                )
+            )
+        );
+    }
+
+    function test_deploy_with_usdc_revert_invalid_eth_transfer() public {
+        address[] memory owners = new address[](1);
+        owners[0] = users.creator;
+
+        dealUSDC(users.creator, 1);
+
+        vm.deal(users.creator, 1e6);
+
+        vm.prank(users.creator);
+        vm.expectRevert(abi.encodeWithSelector(ICoin.EthTransferInvalid.selector));
+        coin = Coin(
+            payable(
+                factory.deploy{value: 1e6}(
+                    users.creator,
+                    owners,
+                    "https://testcoinusdcpair.com",
+                    "Testcoinusdcpair",
+                    "TESTCOINUSDCPAIR",
+                    users.platformReferrer,
+                    USDC_ADDRESS,
+                    USDC_TICK_LOWER,
+                    0
+                )
+            )
+        );
+    }
+
+    function test_deploy_without_initial_order() public {
+        address[] memory owners = new address[](1);
+        owners[0] = users.creator;
+
+        coin = Coin(
+            payable(
+                factory.deploy(users.creator, owners, "https://test.com", "Test Token", "TEST", users.platformReferrer, address(weth), LP_TICK_LOWER_WETH, 0)
+            )
+        );
+
+        assertEq(coin.balanceOf(users.creator), 10_000_000e18, "Should only have initial creator allocation");
+    }
+
+    function test_upgrade() public {
+        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinImpl));
+
+        vm.prank(users.factoryOwner);
+        factory.upgradeToAndCall(address(newImpl), "");
+
+        assertEq(factory.implementation(), address(newImpl), "implementation");
+    }
+
+    function test_revert_invalid_upgrade_impl() public {
+        address newImpl = address(this);
+
+        vm.prank(users.factoryOwner);
+        vm.expectRevert(abi.encodeWithSelector(ERC1967Utils.ERC1967InvalidImplementation.selector, address(newImpl)));
+        factory.upgradeToAndCall(address(newImpl), "");
+    }
+
+    function test_revert_invalid_owner() public {
+        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinImpl));
+
+        vm.prank(users.creator);
+        vm.expectRevert(abi.encodeWithSelector(OwnableUpgradeable.OwnableUnauthorizedAccount.selector, users.creator));
+        factory.upgradeToAndCall(address(newImpl), "");
+    }
+}

package/test/MultiOwnable.t.sol

@@ -0,0 +1,156 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import "./utils/BaseTest.sol";
+
+contract MultiOwnableTest is BaseTest {
+    function setUp() public override {
+        super.setUp();
+
+        _deployCoin();
+    }
+
+    function test_initial_owners() public view {
+        assertEq(coin.owners().length, 1);
+        assertEq(coin.owners()[0], users.creator);
+        assertEq(coin.isOwner(users.creator), true);
+    }
+
+    function test_add_owners() public {
+        address[] memory newOwners = new address[](2);
+        newOwners[0] = makeAddr("NewOwner1");
+        newOwners[1] = makeAddr("NewOwner2");
+
+        vm.prank(users.creator);
+        coin.addOwners(newOwners);
+
+        assertEq(coin.owners().length, 3);
+        assertEq(coin.isOwner(users.creator), true);
+        assertEq(coin.isOwner(newOwners[0]), true);
+        assertEq(coin.isOwner(newOwners[1]), true);
+    }
+
+    function test_add_owner() public {
+        vm.prank(users.creator);
+        coin.addOwner(address(this));
+
+        assertEq(coin.owners().length, 2);
+        assertEq(coin.isOwner(users.creator), true);
+        assertEq(coin.isOwner(address(this)), true);
+    }
+
+    function test_remove_owners() public {
+        address[] memory newOwners = new address[](2);
+        newOwners[0] = makeAddr("NewOwner1");
+        newOwners[1] = makeAddr("NewOwner2");
+
+        vm.prank(users.creator);
+        coin.addOwners(newOwners);
+
+        vm.prank(users.creator);
+        coin.removeOwners(newOwners);
+
+        assertEq(coin.owners().length, 1);
+        assertEq(coin.isOwner(users.creator), true);
+        assertEq(coin.isOwner(newOwners[0]), false);
+        assertEq(coin.isOwner(newOwners[1]), false);
+    }
+
+    function test_remove_owner() public {
+        vm.prank(users.creator);
+        coin.addOwner(address(this));
+
+        vm.prank(address(this));
+        coin.removeOwner(users.creator);
+
+        assertEq(coin.owners().length, 1);
+        assertEq(coin.isOwner(users.creator), false);
+        assertEq(coin.isOwner(address(this)), true);
+    }
+
+    function test_revert_only_owner_can_add() public {
+        vm.expectRevert(abi.encodeWithSelector(MultiOwnable.OnlyOwner.selector));
+        coin.addOwner(address(this));
+    }
+
+    function test_revert_only_owner_can_remove() public {
+        vm.expectRevert(abi.encodeWithSelector(MultiOwnable.OnlyOwner.selector));
+
+        vm.prank(address(this));
+        coin.removeOwner(users.creator);
+    }
+
+    function test_revert_cannot_remove_not_owner() public {
+        vm.expectRevert(abi.encodeWithSelector(MultiOwnable.NotOwner.selector));
+        vm.prank(users.creator);
+        coin.removeOwner(address(this));
+    }
+
+    function test_revert_last_owner_must_revoke() public {
+        address newOwner = makeAddr("NewOwner1");
+
+        vm.prank(users.creator);
+        coin.addOwner(newOwner);
+
+        vm.prank(newOwner);
+        coin.removeOwner(users.creator);
+
+        vm.prank(newOwner);
+        vm.expectRevert(abi.encodeWithSelector(MultiOwnable.UseRevokeOwnershipToRemoveSelf.selector));
+        coin.removeOwner(newOwner);
+    }
+
+    function test_revoke_ownership() public {
+        vm.prank(users.creator);
+        coin.revokeOwnership();
+
+        assertEq(coin.owners().length, 0);
+        assertEq(coin.isOwner(users.creator), false);
+    }
+
+    function test_revert_add_owners_with_zero_address() public {
+        address newOwner = makeAddr("NewOwner1");
+        address[] memory newOwners = new address[](2);
+        newOwners[0] = newOwner;
+        newOwners[1] = address(0);
+
+        vm.prank(users.creator);
+        vm.expectRevert(MultiOwnable.OwnerCannotBeAddressZero.selector);
+        coin.addOwners(newOwners);
+    }
+
+    function test_revert_add_owners_with_duplicate() public {
+        address newOwner = makeAddr("NewOwner1");
+        address[] memory newOwners = new address[](2);
+        newOwners[0] = newOwner;
+        newOwners[1] = newOwner;
+
+        vm.prank(users.creator);
+        coin.addOwner(newOwner);
+
+        vm.expectRevert(MultiOwnable.AlreadyOwner.selector);
+        vm.prank(users.creator);
+        coin.addOwners(newOwners);
+    }
+
+    function test_revert_init_with_zero_owners() public {
+        address[] memory emptyOwners = new address[](0);
+        vm.expectRevert(MultiOwnable.OneOwnerRequired.selector);
+        factory.deploy(users.creator, emptyOwners, "https://test.com", "Test Token", "TEST", users.platformReferrer, address(0), 0, 0);
+    }
+
+    function test_revert_init_with_zero_address() public {
+        address[] memory owners = new address[](1);
+        owners[0] = address(0);
+        vm.expectRevert(MultiOwnable.OwnerCannotBeAddressZero.selector);
+        factory.deploy(users.creator, owners, "https://test.com", "Test Token", "TEST", users.platformReferrer, address(0), 0, 0);
+    }
+
+    function test_revert_init_with_duplicate_owner() public {
+        address[] memory owners = new address[](2);
+        owners[0] = users.creator;
+        owners[1] = users.creator;
+        vm.expectRevert(MultiOwnable.AlreadyOwner.selector);
+        factory.deploy(users.creator, owners, "https://test.com", "Test Token", "TEST", users.platformReferrer, address(0), 0, 0);
+    }
+}

package/test/utils/BaseTest.sol

@@ -0,0 +1,178 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import "forge-std/Test.sol";
+
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+import {ERC1967Utils} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+import {ZoraFactoryImpl} from "../../src/ZoraFactoryImpl.sol";
+import {ZoraFactory} from "../../src/proxy/ZoraFactory.sol";
+import {Coin} from "../../src/Coin.sol";
+import {CoinConstants} from "../../src/utils/CoinConstants.sol";
+import {MultiOwnable} from "../../src/utils/MultiOwnable.sol";
+import {ICoin} from "../../src/interfaces/ICoin.sol";
+import {IERC7572} from "../../src/interfaces/IERC7572.sol";
+import {IWETH} from "../../src/interfaces/IWETH.sol";
+import {INonfungiblePositionManager} from "../../src/interfaces/INonfungiblePositionManager.sol";
+import {ISwapRouter} from "../../src/interfaces/ISwapRouter.sol";
+import {IUniswapV3Pool} from "../../src/interfaces/IUniswapV3Pool.sol";
+import {IProtocolRewards} from "../../src/interfaces/IProtocolRewards.sol";
+import {ProtocolRewards} from "../utils/ProtocolRewards.sol";
+
+contract BaseTest is Test, CoinConstants {
+    using stdStorage for StdStorage;
+
+    address internal constant PROTOCOL_REWARDS = 0x7777777F279eba3d3Ad8F4E708545291A6fDBA8B;
+    address internal constant WETH_ADDRESS = 0x4200000000000000000000000000000000000006;
+    address internal constant NONFUNGIBLE_POSITION_MANAGER = 0x03a520b32C04BF3bEEf7BEb72E919cf822Ed34f1;
+    address internal constant SWAP_ROUTER = 0x2626664c2603336E57B271c5C0b26F421741e481;
+    address internal constant USDC_ADDRESS = 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913;
+    int24 internal constant USDC_TICK_LOWER = 57200;
+
+    struct Users {
+        address factoryOwner;
+        address feeRecipient;
+        address creator;
+        address platformReferrer;
+        address buyer;
+        address seller;
+        address coinRecipient;
+        address tradeReferrer;
+    }
+
+    uint256 internal forkId;
+    IERC20Metadata internal usdc;
+    IWETH internal weth;
+    ProtocolRewards internal protocolRewards;
+    INonfungiblePositionManager internal nonfungiblePositionManager;
+    ISwapRouter internal swapRouter;
+    Users internal users;
+
+    Coin internal coinImpl;
+    ZoraFactoryImpl internal factoryImpl;
+    ZoraFactoryImpl internal factory;
+    Coin internal coin;
+    IUniswapV3Pool internal pool;
+
+    function setUp() public virtual {
+        forkId = vm.createSelectFork("https://mainnet.base.org", 21179722);
+
+        weth = IWETH(WETH_ADDRESS);
+        usdc = IERC20Metadata(USDC_ADDRESS);
+        nonfungiblePositionManager = INonfungiblePositionManager(NONFUNGIBLE_POSITION_MANAGER);
+        swapRouter = ISwapRouter(SWAP_ROUTER);
+        protocolRewards = new ProtocolRewards();
+
+        users = Users({
+            factoryOwner: makeAddr("factoryOwner"),
+            feeRecipient: makeAddr("feeRecipient"),
+            creator: makeAddr("creator"),
+            platformReferrer: makeAddr("platformReferrer"),
+            buyer: makeAddr("buyer"),
+            seller: makeAddr("seller"),
+            coinRecipient: makeAddr("coinRecipient"),
+            tradeReferrer: makeAddr("tradeReferrer")
+        });
+
+        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)))
+        );
+
+        vm.label(address(factory), "ZORA_FACTORY");
+        vm.label(address(protocolRewards), "PROTOCOL_REWARDS");
+        vm.label(address(nonfungiblePositionManager), "NONFUNGIBLE_POSITION_MANAGER");
+        vm.label(address(swapRouter), "SWAP_ROUTER");
+        vm.label(address(weth), "WETH");
+        vm.label(address(usdc), "USDC");
+    }
+
+    struct TradeRewards {
+        uint256 creator;
+        uint256 platformReferrer;
+        uint256 tradeReferrer;
+        uint256 protocol;
+    }
+
+    struct MarketRewards {
+        uint256 creator;
+        uint256 platformReferrer;
+        uint256 protocol;
+    }
+
+    function _deployCoin() internal {
+        address[] memory owners = new address[](1);
+        owners[0] = users.creator;
+
+        vm.prank(users.creator);
+        coin = Coin(
+            payable(factory.deploy(users.creator, owners, "https://test.com", "Testcoin", "TEST", users.platformReferrer, address(weth), LP_TICK_LOWER_WETH, 0))
+        );
+        pool = IUniswapV3Pool(coin.poolAddress());
+
+        vm.label(address(coin), "COIN");
+        vm.label(address(pool), "POOL");
+    }
+
+    function _deployCoinUSDCPair() internal {
+        address[] memory owners = new address[](1);
+        owners[0] = users.creator;
+
+        vm.prank(users.creator);
+        coin = Coin(
+            payable(
+                factory.deploy(
+                    users.creator,
+                    owners,
+                    "https://testusdccoin.com",
+                    "Testusdccoin",
+                    "TESTUSDCCOIN",
+                    users.platformReferrer,
+                    USDC_ADDRESS,
+                    USDC_TICK_LOWER,
+                    0
+                )
+            )
+        );
+        pool = IUniswapV3Pool(coin.poolAddress());
+
+        vm.label(address(coin), "COIN");
+        vm.label(address(pool), "POOL");
+    }
+
+    function _calculateTradeRewards(uint256 ethAmount) internal pure returns (TradeRewards memory) {
+        return
+            TradeRewards({
+                creator: (ethAmount * 5000) / 10_000,
+                platformReferrer: (ethAmount * 1500) / 10_000,
+                tradeReferrer: (ethAmount * 1500) / 10_000,
+                protocol: (ethAmount * 2000) / 10_000
+            });
+    }
+
+    function _calculateExpectedFee(uint256 ethAmount) internal pure returns (uint256) {
+        uint256 feeBps = 100; // 1%
+        return (ethAmount * feeBps) / 10_000;
+    }
+
+    function _calculateMarketRewards(uint256 ethAmount) internal pure returns (MarketRewards memory) {
+        uint256 creator = (ethAmount * 5000) / 10_000;
+        uint256 platformReferrer = (ethAmount * 2500) / 10_000;
+        uint256 protocol = ethAmount - creator - platformReferrer;
+
+        return MarketRewards({creator: creator, platformReferrer: platformReferrer, protocol: protocol});
+    }
+
+    function dealUSDC(address to, uint256 numUSDC) internal returns (uint256) {
+        uint256 amount = numUSDC * 1e6;
+        deal(address(usdc), to, amount);
+        return amount;
+    }
+
+    function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata data) external {}
+}