@zoralabs/comments-contracts 0.0.1 → 0.0.2-COMMENTS.0

package/test/CallerAndCommenter_swapAndComment.t.sol

@@ -0,0 +1,523 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {IComments} from "../src/interfaces/IComments.sol";
+import {ICallerAndCommenter} from "../src/interfaces/ICallerAndCommenter.sol";
+import {CallerAndCommenterTestBase} from "./CallerAndCommenterTestBase.sol";
+import {ISecondarySwap} from "../src/interfaces/ISecondarySwap.sol";
+import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import {CallerAndCommenterImpl} from "../src/utils/CallerAndCommenterImpl.sol";
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import {IERC1155} from "@openzeppelin/contracts/interfaces/IERC1155.sol";
+import {IERC1155Receiver} from "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
+
+contract CallerAndCommenterSwapAndCommentTest is CallerAndCommenterTestBase {
+    function testBuyOnSecondaryAndComment() public {
+        // setup the sale so that we have a link between the erc20z and the 1155
+        address erc20z = mockMinter.setSale(address(mock1155), tokenId1);
+
+        uint256 quantity = 5;
+
+        address excessRefundRecipient = makeAddr("excessRefundRecipient");
+        uint256 maxEthToSpend = 2 ether;
+        uint160 sqrtPriceLimitX96 = 1000;
+        string memory comment = "test comment";
+
+        IComments.CommentIdentifier memory expectedCommentIdentifier = _expectedCommentIdentifier(commenter, address(mock1155), tokenId1);
+        bytes32 expectedCommentId = comments.hashCommentIdentifier(expectedCommentIdentifier);
+
+        uint256 valueToSpend = 1 ether;
+        vm.deal(commenter, valueToSpend);
+
+        vm.expectEmit(true, true, true, true);
+        emit IComments.Commented(expectedCommentId, expectedCommentIdentifier, bytes32(0), emptyCommentIdentifier, 0, comment, block.timestamp, address(0));
+        vm.expectEmit(true, true, true, true);
+        emit ICallerAndCommenter.SwappedOnSecondaryAndCommented(
+            expectedCommentId,
+            expectedCommentIdentifier,
+            quantity,
+            comment,
+            ICallerAndCommenter.SwapDirection.BUY
+        );
+
+        vm.expectCall(
+            address(mockSecondarySwap),
+            valueToSpend,
+            abi.encodeWithSelector(ISecondarySwap.buy1155.selector, erc20z, quantity, commenter, excessRefundRecipient, maxEthToSpend, sqrtPriceLimitX96)
+        );
+
+        vm.prank(commenter);
+        callerAndCommenter.buyOnSecondaryAndComment{value: valueToSpend}({
+            commenter: commenter,
+            quantity: quantity,
+            collection: address(mock1155),
+            tokenId: tokenId1,
+            excessRefundRecipient: payable(excessRefundRecipient),
+            maxEthToSpend: maxEthToSpend,
+            sqrtPriceLimitX96: sqrtPriceLimitX96,
+            comment: comment
+        });
+    }
+
+    function testBuyOnSecondaryAndComment_revertsWhenSaleNotSet() public {
+        vm.expectRevert(abi.encodeWithSelector(ICallerAndCommenter.SaleNotSet.selector, address(mock1155), tokenId1));
+        vm.prank(commenter);
+        callerAndCommenter.buyOnSecondaryAndComment({
+            commenter: commenter,
+            quantity: 1,
+            collection: address(mock1155),
+            tokenId: tokenId1,
+            excessRefundRecipient: payable(address(0)),
+            maxEthToSpend: 0,
+            sqrtPriceLimitX96: 0,
+            comment: "test comment"
+        });
+    }
+
+    function testBuyOnSecondaryAndComment_revertsWhenCommenterMismatch() public {
+        address commenter2 = makeAddr("commenter2");
+        vm.expectRevert(abi.encodeWithSelector(ICallerAndCommenter.CommenterMismatch.selector, commenter2, commenter));
+        vm.prank(commenter2);
+        callerAndCommenter.buyOnSecondaryAndComment({
+            commenter: commenter,
+            quantity: 1,
+            collection: address(mock1155),
+            tokenId: tokenId1,
+            excessRefundRecipient: payable(address(0)),
+            maxEthToSpend: 0,
+            sqrtPriceLimitX96: 0,
+            comment: "test comment"
+        });
+    }
+
+    function testBuyOnSecondaryAndCommentWhenNoCommentDoesNotComment() public {
+        uint256 quantity = 1;
+        uint256 maxEthToSpend = 0.2 ether;
+        uint160 sqrtPriceLimitX96 = 0;
+        address excessRefundRecipient = address(0);
+
+        mockMinter.setSale(address(mock1155), tokenId1);
+
+        vm.prank(commenter);
+        IComments.CommentIdentifier memory result = callerAndCommenter.buyOnSecondaryAndComment({
+            commenter: commenter,
+            quantity: quantity,
+            collection: address(mock1155),
+            tokenId: tokenId1,
+            excessRefundRecipient: payable(excessRefundRecipient),
+            maxEthToSpend: maxEthToSpend,
+            sqrtPriceLimitX96: sqrtPriceLimitX96,
+            comment: ""
+        });
+
+        assertEq(result.commenter, address(0));
+        assertEq(result.contractAddress, address(0));
+        assertEq(result.tokenId, 0);
+        assertEq(result.nonce, bytes32(0));
+    }
+
+    function upgradeForkCallerAndCommenterToNewImplementation() internal {
+        // upgrade the current caller and commenter on the fork to the new implementation
+        address COMMENTS = 0x7777777C2B3132e03a65721a41745C07170a5877;
+        address ZORA_TIMED_SALE_STRATEGY = 0x777777722D078c97c6ad07d9f36801e653E356Ae;
+        address SECONDARY_SWAP = 0x777777EDF27Ac61671e3D5718b10bf6a8802f9f1;
+        // deploy the new implementation
+        CallerAndCommenterImpl callerAndCallerImp = new CallerAndCommenterImpl(COMMENTS, ZORA_TIMED_SALE_STRATEGY, SECONDARY_SWAP, SPARKS_VALUE);
+        // here we override the caller and commenter with the current one on the fork
+        callerAndCommenter = ICallerAndCommenter(0x77777775C5074b74540d9cC63Dd840A8c692B4B5);
+        // upgrade to the new implementation
+        address owner = OwnableUpgradeable(address(callerAndCommenter)).owner();
+        vm.prank(owner);
+        UUPSUpgradeable(address(callerAndCommenter)).upgradeToAndCall(address(callerAndCallerImp), "");
+    }
+
+    function testFork_buyOnSecondaryAndComment() public {
+        // upgrade the forked caller and commenter to the new implementation
+        upgradeForkCallerAndCommenterToNewImplementation();
+        // this is a known zora test collection where we can secondary swap
+        address test1155Address = 0xE79585bF83BbBfAE0fB80222b0a72F2c1D040612;
+        uint256 testTokenId = 1;
+
+        address excessRefundRecipient = makeAddr("excessRefundRecipient");
+        uint256 maxEthToSpend = 237222215770897;
+        uint160 sqrtPriceLimitX96 = 0;
+        string memory comment = "test comment";
+
+        IComments.CommentIdentifier memory expectedCommentIdentifier = IComments.CommentIdentifier({
+            commenter: commenter,
+            contractAddress: test1155Address,
+            tokenId: testTokenId,
+            // we need to get the nonce from the fork comments contract
+            nonce: callerAndCommenter.comments().nextNonce()
+        });
+        bytes32 expectedCommentId = callerAndCommenter.comments().hashCommentIdentifier(expectedCommentIdentifier);
+
+        uint256 quantity = 1;
+        uint256 valueToSpend = maxEthToSpend;
+        vm.deal(commenter, valueToSpend);
+
+        vm.expectEmit(true, true, true, true);
+        emit IComments.Commented(expectedCommentId, expectedCommentIdentifier, bytes32(0), emptyCommentIdentifier, 0, comment, block.timestamp, address(0));
+        vm.expectEmit(true, true, true, true);
+        emit ICallerAndCommenter.SwappedOnSecondaryAndCommented(
+            expectedCommentId,
+            expectedCommentIdentifier,
+            quantity,
+            comment,
+            ICallerAndCommenter.SwapDirection.BUY
+        );
+
+        // call the caller and commenter contract
+        vm.prank(commenter);
+        callerAndCommenter.buyOnSecondaryAndComment{value: valueToSpend}({
+            commenter: commenter,
+            quantity: quantity,
+            collection: test1155Address,
+            tokenId: testTokenId,
+            excessRefundRecipient: payable(excessRefundRecipient),
+            maxEthToSpend: maxEthToSpend,
+            sqrtPriceLimitX96: sqrtPriceLimitX96,
+            comment: comment
+        });
+    }
+
+    function testPermitBuyOnSecondaryAndComment() public {
+        uint256 quantity = 5;
+        uint256 valueToSpend = 1 ether;
+
+        address contractAddress = address(mock1155);
+        uint256 tokenId = tokenId1;
+
+        string memory comment = "test comment";
+
+        address erc20z = mockMinter.setSale(contractAddress, tokenId);
+
+        ICallerAndCommenter.PermitBuyOnSecondaryAndComment memory permit = _createPermitBuy(
+            commenter,
+            quantity,
+            contractAddress,
+            tokenId,
+            2 ether,
+            1000,
+            comment,
+            block.timestamp + 1 hours
+        );
+
+        bytes memory signature = _signPermit(permit, commenterPrivateKey);
+
+        IComments.CommentIdentifier memory expectedCommentIdentifier = _expectedCommentIdentifier(commenter, contractAddress, tokenId);
+
+        bytes32 expectedCommentId = comments.hashCommentIdentifier(expectedCommentIdentifier);
+
+        vm.deal(commenter, valueToSpend);
+        vm.expectEmit(true, true, true, true);
+        emit IComments.Commented(expectedCommentId, expectedCommentIdentifier, bytes32(0), emptyCommentIdentifier, 0, comment, block.timestamp, address(0));
+        vm.expectEmit(true, true, true, true);
+        emit ICallerAndCommenter.SwappedOnSecondaryAndCommented(
+            expectedCommentId,
+            expectedCommentIdentifier,
+            quantity,
+            comment,
+            ICallerAndCommenter.SwapDirection.BUY
+        );
+
+        vm.expectCall(
+            address(mockSecondarySwap),
+            valueToSpend,
+            abi.encodeWithSelector(
+                ISecondarySwap.buy1155.selector,
+                erc20z,
+                quantity,
+                commenter,
+                permit.commenter,
+                permit.maxEthToSpend,
+                permit.sqrtPriceLimitX96
+            )
+        );
+
+        IComments.CommentIdentifier memory result = callerAndCommenter.permitBuyOnSecondaryAndComment{value: valueToSpend}(permit, signature);
+
+        assertEq(result.commenter, commenter);
+        assertEq(result.contractAddress, contractAddress);
+        assertEq(result.tokenId, tokenId);
+        assertEq(result.nonce, bytes32(0));
+
+        // validate that the comment was created
+        (, bool exists) = comments.hashAndCheckCommentExists(expectedCommentIdentifier);
+        assertEq(exists, true);
+    }
+
+    function testPermitBuyOnSecondaryAndComment_ExpiredDeadline() public {
+        ICallerAndCommenter.PermitBuyOnSecondaryAndComment memory permit = _createPermitBuy(
+            commenter,
+            1,
+            address(mock1155),
+            tokenId1,
+            1 ether,
+            1000,
+            "test comment",
+            block.timestamp - 1 // Expired deadline
+        );
+
+        bytes memory signature = _signPermit(permit, commenterPrivateKey);
+
+        vm.expectRevert(abi.encodeWithSelector(IComments.ERC2612ExpiredSignature.selector, permit.deadline));
+        callerAndCommenter.permitBuyOnSecondaryAndComment{value: 1 ether}(permit, signature);
+    }
+
+    function testPermitBuyOnSecondaryAndComment_InvalidSignature() public {
+        ICallerAndCommenter.PermitBuyOnSecondaryAndComment memory permit = _createPermitBuy(
+            commenter,
+            1,
+            address(mock1155),
+            tokenId1,
+            1 ether,
+            1000,
+            "test comment",
+            block.timestamp + 1 hours
+        );
+
+        bytes memory signature = _signPermit(permit, 5); // Wrong signer
+
+        vm.expectRevert(IComments.InvalidSignature.selector);
+        callerAndCommenter.permitBuyOnSecondaryAndComment{value: 1 ether}(permit, signature);
+    }
+
+    function testPermitBuyOnSecondaryAndComment_IncorrectDestinationChain() public {
+        ICallerAndCommenter.PermitBuyOnSecondaryAndComment memory permit = _createPermitBuy(
+            commenter,
+            1,
+            address(mock1155),
+            tokenId1,
+            1 ether,
+            1000,
+            "test comment",
+            block.timestamp + 1 hours
+        );
+        permit.destinationChainId = uint32(block.chainid) + 1; // Incorrect destination chain
+
+        bytes memory signature = _signPermit(permit, commenterPrivateKey);
+
+        vm.expectRevert(abi.encodeWithSelector(ICallerAndCommenter.IncorrectDestinationChain.selector, permit.destinationChainId));
+        callerAndCommenter.permitBuyOnSecondaryAndComment{value: 1 ether}(permit, signature);
+    }
+
+    function testSellOnSecondaryAndComment() public {
+        // setup the sale so that we have a link between the erc20z and the 1155
+        mockMinter.setSale(address(mock1155), tokenId1);
+
+        uint256 quantityToSwap = 5;
+        mock1155.mint(commenter, tokenId1, quantityToSwap, "");
+
+        address payable recipient = payable(makeAddr("recipient"));
+        uint256 minEthToAcquire = 1 ether;
+        uint160 sqrtPriceLimitX96 = 1000;
+        string memory comment = "test comment";
+
+        IComments.CommentIdentifier memory expectedCommentIdentifier = _expectedCommentIdentifier(commenter, address(mock1155), tokenId1);
+        bytes32 expectedCommentId = comments.hashCommentIdentifier(expectedCommentIdentifier);
+
+        bytes memory expectedData = abi.encode(recipient, minEthToAcquire, sqrtPriceLimitX96);
+
+        // commenter needs to approve the caller to transfer the 1155s
+        // since it is to transfer to the secondary swap
+        vm.prank(commenter);
+        IERC1155(address(mock1155)).setApprovalForAll(address(callerAndCommenter), true);
+
+        vm.expectEmit(true, true, true, true);
+        emit IComments.Commented({
+            commentId: expectedCommentId,
+            commentIdentifier: expectedCommentIdentifier,
+            replyToId: bytes32(0),
+            replyTo: emptyCommentIdentifier,
+            sparksQuantity: 1,
+            text: comment,
+            timestamp: block.timestamp,
+            referrer: address(0)
+        });
+        vm.expectEmit(true, true, true, true);
+        emit ICallerAndCommenter.SwappedOnSecondaryAndCommented(
+            expectedCommentId,
+            expectedCommentIdentifier,
+            quantityToSwap,
+            comment,
+            ICallerAndCommenter.SwapDirection.SELL
+        );
+
+        // make sure the mock secondary swap received the 1155s
+        // using the expected call
+        vm.expectCall(
+            address(mockSecondarySwap),
+            0,
+            abi.encodeWithSelector(IERC1155Receiver.onERC1155Received.selector, address(callerAndCommenter), commenter, tokenId1, quantityToSwap, expectedData)
+        );
+
+        vm.deal(commenter, SPARKS_VALUE);
+        vm.prank(commenter);
+        callerAndCommenter.sellOnSecondaryAndComment{value: SPARKS_VALUE}(
+            commenter,
+            quantityToSwap,
+            address(mock1155),
+            tokenId1,
+            recipient,
+            minEthToAcquire,
+            sqrtPriceLimitX96,
+            comment
+        );
+
+        // make sure the mock secondary swap received the 1155s
+        assertEq(IERC1155(address(mock1155)).balanceOf(address(mockSecondarySwap), tokenId1), quantityToSwap);
+    }
+
+    function testFork_sellOnSecondaryAndComment() public {
+        // upgrade the forked caller and commenter to the new implementation
+        upgradeForkCallerAndCommenterToNewImplementation();
+        // this is a known zora test collection where we can secondary swap
+        address test1155Address = 0xE79585bF83BbBfAE0fB80222b0a72F2c1D040612;
+        uint256 testTokenId = 1;
+
+        uint256 quantityToBuy = 5;
+
+        uint256 maxEthToSpend = 237222215770897 * quantityToBuy;
+        uint256 valueToSpend = maxEthToSpend;
+
+        // first we need to buy the 1155s on secondary
+        vm.deal(commenter, valueToSpend);
+        vm.prank(commenter);
+        callerAndCommenter.buyOnSecondaryAndComment{value: valueToSpend}({
+            commenter: commenter,
+            quantity: quantityToBuy,
+            collection: test1155Address,
+            tokenId: testTokenId,
+            excessRefundRecipient: payable(commenter),
+            maxEthToSpend: maxEthToSpend,
+            sqrtPriceLimitX96: 0,
+            comment: "test comment when buying"
+        });
+
+        // now we can sell the 1155s on secondary
+
+        uint256 quantityToSell = 3;
+        string memory sellingComment = "test comment when selling";
+
+        vm.prank(commenter);
+        IERC1155(address(test1155Address)).setApprovalForAll(address(callerAndCommenter), true);
+
+        // perform the sell
+        vm.deal(commenter, SPARKS_VALUE);
+        vm.prank(commenter);
+        callerAndCommenter.sellOnSecondaryAndComment{value: SPARKS_VALUE}({
+            commenter: commenter,
+            quantity: quantityToSell,
+            collection: test1155Address,
+            tokenId: testTokenId,
+            recipient: payable(commenter),
+            minEthToAcquire: 0,
+            sqrtPriceLimitX96: 0,
+            comment: sellingComment
+        });
+    }
+
+    function testSellOnSecondaryAndComment_CommenterMismatch() public {
+        vm.expectRevert(abi.encodeWithSelector(ICallerAndCommenter.CommenterMismatch.selector, commenter, makeAddr("other")));
+        vm.prank(commenter);
+        callerAndCommenter.sellOnSecondaryAndComment(makeAddr("other"), 1, address(mock1155), tokenId1, payable(address(0)), 1 ether, 1000, "test comment");
+    }
+
+    function testSellOnSecondaryAndComment_SaleNotSet() public {
+        uint256 quantityToSwap = 5;
+        mock1155.mint(commenter, tokenId1, quantityToSwap, "");
+        vm.prank(commenter);
+        IERC1155(address(mock1155)).setApprovalForAll(address(callerAndCommenter), true);
+
+        vm.expectRevert(ISecondarySwap.SaleNotSet.selector);
+        vm.prank(commenter);
+        vm.deal(commenter, SPARKS_VALUE);
+        callerAndCommenter.sellOnSecondaryAndComment{value: SPARKS_VALUE}(
+            commenter,
+            1,
+            address(mock1155),
+            tokenId1,
+            payable(address(0)),
+            1 ether,
+            1000,
+            "test comment"
+        );
+    }
+
+    function testSellOnSecondaryAndComment_RevertsWhenNotOneSparkAndACommentIsSent(uint16 sparksQuantity, bool commentIsSent) public {
+        uint256 valueToSend = sparksQuantity * SPARKS_VALUE;
+        // setup the sale so that we have a link between the erc20z and the 1155
+        mockMinter.setSale(address(mock1155), tokenId1);
+
+        uint256 quantityToSwap = 5;
+        mock1155.mint(commenter, tokenId1, quantityToSwap, "");
+
+        address recipient = makeAddr("recipient");
+        uint256 minEthToAcquire = 1 ether;
+        uint160 sqrtPriceLimitX96 = 1000;
+        string memory comment = commentIsSent ? "test comment" : "";
+
+        // commenter needs to approve the caller to transfer the 1155s
+        // since it is to transfer to the secondary swap
+        vm.prank(commenter);
+        IERC1155(address(mock1155)).setApprovalForAll(address(callerAndCommenter), true);
+
+        // if we are sending a comment, we should be required to send one spark
+        if (commentIsSent) {
+            if (sparksQuantity != 1) {
+                vm.expectRevert(abi.encodeWithSelector(ICallerAndCommenter.WrongValueSent.selector, SPARKS_VALUE, valueToSend));
+            }
+        } else {
+            // if we are not sending a comment, we should not send any ETH
+            if (valueToSend != 0) {
+                vm.expectRevert(abi.encodeWithSelector(ICallerAndCommenter.WrongValueSent.selector, 0, valueToSend));
+            }
+        }
+
+        vm.deal(commenter, valueToSend);
+        vm.prank(commenter);
+        callerAndCommenter.sellOnSecondaryAndComment{value: valueToSend}(
+            commenter,
+            quantityToSwap,
+            address(mock1155),
+            tokenId1,
+            payable(recipient),
+            minEthToAcquire,
+            sqrtPriceLimitX96,
+            comment
+        );
+    }
+
+    function _createPermitBuy(
+        address _commenter,
+        uint256 _quantity,
+        address _collection,
+        uint256 _tokenId,
+        uint256 _maxEthToSpend,
+        uint160 _sqrtPriceLimitX96,
+        string memory _comment,
+        uint256 _deadline
+    ) internal view returns (ICallerAndCommenter.PermitBuyOnSecondaryAndComment memory) {
+        return
+            ICallerAndCommenter.PermitBuyOnSecondaryAndComment({
+                commenter: _commenter,
+                quantity: _quantity,
+                collection: _collection,
+                tokenId: _tokenId,
+                maxEthToSpend: _maxEthToSpend,
+                sqrtPriceLimitX96: _sqrtPriceLimitX96,
+                comment: _comment,
+                deadline: _deadline,
+                nonce: bytes32(0),
+                sourceChainId: uint32(block.chainid),
+                destinationChainId: uint32(block.chainid)
+            });
+    }
+
+    function _signPermit(ICallerAndCommenter.PermitBuyOnSecondaryAndComment memory _permit, uint256 _privateKey) internal view returns (bytes memory) {
+        bytes32 digest = callerAndCommenter.hashPermitBuyOnSecondaryAndComment(_permit);
+        (uint8 v, bytes32 r, bytes32 s) = vm.sign(_privateKey, digest);
+        return abi.encodePacked(r, s, v);
+    }
+}