@zoralabs/coins 1.0.0 → 1.0.1

package/test/Upgrades.t.sol

@@ -4,6 +4,17 @@ import {Test} from "forge-std/Test.sol";
 import {IZoraFactory} from "../src/interfaces/IZoraFactory.sol";
 import {ZoraFactoryImpl} from "../src/ZoraFactoryImpl.sol";
 import {BaseTest} from "./utils/BaseTest.sol";
+import {CoinsDeployerBase} from "../src/deployment/CoinsDeployerBase.sol";
+import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
+import {ICoinV4} from "../src/interfaces/ICoinV4.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {ISwapRouter} from "../src/interfaces/ISwapRouter.sol";
+import {IWETH} from "../src/interfaces/IWETH.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
+import {BuySupplyWithSwapRouterHook} from "../src/hooks/deployment/BuySupplyWithSwapRouterHook.sol";
+
+import {console} from "forge-std/console.sol";
 
 contract BadImpl {
     function contractName() public pure returns (string memory) {
@@ -11,7 +22,7 @@ contract BadImpl {
     }
 }
 
-contract UpgradesTest is BaseTest {
+contract UpgradesTest is BaseTest, CoinsDeployerBase {
     ZoraFactoryImpl public factoryProxy;
 
     function test_canUpgradeFromVersionWithoutContractName() public {
@@ -65,4 +76,84 @@ contract UpgradesTest is BaseTest {
 
         assertEq(factoryProxy.implementation(), address(newImpl2));
     }
+
+    function test_canUpgradeAndSwap() public {
+        vm.createSelectFork("base");
+
+        factoryProxy = ZoraFactoryImpl(0x777777751622c0d3258f214F9DF38E35BF45baF3);
+
+        CoinsDeployment memory deployment = readDeployment();
+
+        vm.prank(factoryProxy.owner());
+        factoryProxy.upgradeToAndCall(deployment.zoraFactoryImpl, "");
+
+        // deploy a v4 coin
+
+        bytes memory poolConfig = CoinConfigurationVersions.defaultDopplerMultiCurveUniV4(ZORA);
+
+        uint128 amountIn = 1 ether;
+
+        address buySupplyWithSwapRouterHook = deployment.buySupplyWithSwapRouterHook;
+
+        // build weth to usdc swap
+        bytes memory call = abi.encodeWithSelector(
+            ISwapRouter.exactInputSingle.selector,
+            ISwapRouter.ExactInputSingleParams({
+                tokenIn: WETH_ADDRESS,
+                tokenOut: ZORA,
+                fee: 3000,
+                recipient: buySupplyWithSwapRouterHook,
+                amountIn: amountIn,
+                amountOutMinimum: 0,
+                sqrtPriceLimitX96: 0
+            })
+        );
+
+        address buyRecipient = makeAddr("buyRecipient");
+
+        address trader = 0xC077e4cC02fa01A5b7fAca1acE9BBe9f5ac5Af9F;
+
+        vm.startPrank(trader);
+        vm.deal(trader, amountIn);
+
+        (address coinAddress, ) = factoryProxy.deploy{value: amountIn}(
+            users.creator,
+            _getDefaultOwners(),
+            "https://test.com",
+            "Testcoin",
+            "TEST",
+            poolConfig,
+            users.platformReferrer,
+            buySupplyWithSwapRouterHook,
+            abi.encode(buyRecipient, call),
+            keccak256("test")
+        );
+
+        // do some swaps to test out
+        _swapSomeCurrencyForCoin(ICoinV4(coinAddress), ZORA, uint128(IERC20(ZORA).balanceOf(trader)), trader);
+
+        // do some swaps to test out
+        _swapSomeCoinForCurrency(ICoinV4(coinAddress), ZORA, uint128(IERC20(coinAddress).balanceOf(trader)), trader);
+    }
+
+    function test_realSwapUsingCurrentCode() external {
+        bytes[] memory inputs = new bytes[](5);
+
+        vm.createSelectFork("base", 31138268);
+
+        address trader = vm.parseAddress("0xa3c881f39972925d865b300bcd65e72a6222c10a");
+
+        ICoinV4 coin = ICoinV4(vm.parseAddress("0xca1de5b8e8336326d5749fde43e245285cd1daf1"));
+
+        PoolKey memory key = coin.getPoolKey();
+
+        address[] memory trustedMessageSenders = new address[](0);
+        deployCodeTo(
+            "ZoraV4CoinHook.sol:ZoraV4CoinHook",
+            abi.encode(V4_POOL_MANAGER, 0x3d7A3f3351855e135CF89AB412A7C2AA449f9296, trustedMessageSenders),
+            address(coin.hooks())
+        );
+
+        _swapSomeCurrencyForCoin(coin, ZORA, uint128(IERC20(ZORA).balanceOf(trader)), trader);
+    }
 }

package/test/utils/BaseTest.sol

@@ -32,11 +32,18 @@ import {ZoraV4CoinHook} from "../../src/hooks/ZoraV4CoinHook.sol";
 import {HooksDeployment} from "../../src/libs/HooksDeployment.sol";
 import {CoinConstants} from "../../src/libs/CoinConstants.sol";
 import {ProxyShim} from "./ProxyShim.sol";
+import {ICoinV4} from "../../src/interfaces/ICoinV4.sol";
+import {UniV4SwapHelper} from "../../src/libs/UniV4SwapHelper.sol";
+import {IPermit2} from "permit2/src/interfaces/IPermit2.sol";
+import {IUniversalRouter} from "@uniswap/universal-router/contracts/interfaces/IUniversalRouter.sol";
+import {Commands} from "@uniswap/universal-router/contracts/libraries/Commands.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {Actions} from "@uniswap/v4-periphery/src/libraries/Actions.sol";
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 
 contract BaseTest is Test {
     using stdStorage for StdStorage;
 
-    address internal constant PROTOCOL_REWARDS = 0x7777777F279eba3d3Ad8F4E708545291A6fDBA8B;
     address internal constant WETH_ADDRESS = 0x4200000000000000000000000000000000000006;
     address internal constant V3_FACTORY = 0x33128a8fC17869897dcE68Ed026d694621f6FDfD;
     address internal constant NONFUNGIBLE_POSITION_MANAGER = 0x03a520b32C04BF3bEEf7BEb72E919cf822Ed34f1;
@@ -67,6 +74,8 @@ contract BaseTest is Test {
     ProtocolRewards internal protocolRewards;
     IUniswapV3Factory internal v3Factory;
     INonfungiblePositionManager internal nonfungiblePositionManager;
+    IPermit2 internal permit2;
+    IUniversalRouter internal router;
 
     ISwapRouter internal swapRouter;
     IAirlock internal airlock;
@@ -141,6 +150,50 @@ contract BaseTest is Test {
         vm.label(address(pool), "POOL");
     }
 
+    function _swapSomeCurrencyForCoin(ICoinV4 _coin, address currency, uint128 amountIn, address trader) internal {
+        uint128 minAmountOut = uint128(0);
+
+        (bytes memory commands, bytes[] memory inputs) = UniV4SwapHelper.buildExactInputSingleSwapCommand(
+            currency,
+            amountIn,
+            address(_coin),
+            minAmountOut,
+            _coin.getPoolKey(),
+            bytes("")
+        );
+
+        vm.startPrank(trader);
+        UniV4SwapHelper.approveTokenWithPermit2(permit2, address(router), currency, amountIn, uint48(block.timestamp + 1 days));
+
+        // Execute the swap
+        uint256 deadline = block.timestamp + 20;
+        router.execute(commands, inputs, deadline);
+
+        vm.stopPrank();
+    }
+
+    function _swapSomeCoinForCurrency(ICoinV4 _coin, address currency, uint128 amountIn, address trader) internal {
+        uint128 minAmountOut = uint128(0);
+
+        (bytes memory commands, bytes[] memory inputs) = UniV4SwapHelper.buildExactInputSingleSwapCommand(
+            address(_coin),
+            amountIn,
+            currency,
+            minAmountOut,
+            _coin.getPoolKey(),
+            bytes("")
+        );
+
+        vm.startPrank(trader);
+        UniV4SwapHelper.approveTokenWithPermit2(permit2, address(router), address(_coin), amountIn, uint48(block.timestamp + 1 days));
+
+        // Execute the swap
+        uint256 deadline = block.timestamp + 20;
+        router.execute(commands, inputs, deadline);
+
+        vm.stopPrank();
+    }
+
     function setUp() public virtual {
         setUpWithBlockNumber(28415528);
     }
@@ -155,6 +208,8 @@ contract BaseTest is Test {
         swapRouter = ISwapRouter(SWAP_ROUTER);
         airlock = IAirlock(DOPPLER_AIRLOCK);
         protocolRewards = new ProtocolRewards();
+        permit2 = IPermit2(V4_PERMIT2);
+        router = IUniversalRouter(UNIVERSAL_ROUTER);
         users = Users({
             factoryOwner: makeAddr("factoryOwner"),
             feeRecipient: makeAddr("feeRecipient"),