@zoralabs/comments-contracts 0.0.1

package/test/Comments_permit.t.sol

@@ -0,0 +1,397 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import "forge-std/Test.sol";
+
+import {CommentsImpl} from "../src/CommentsImpl.sol";
+import {Comments} from "../src/proxy/Comments.sol";
+import {IComments} from "../src/interfaces/IComments.sol";
+import {Mock1155} from "./mocks/Mock1155.sol";
+import {IProtocolRewards} from "@zoralabs/protocol-rewards/src/interfaces/IProtocolRewards.sol";
+import {ProtocolRewards} from "./mocks/ProtocolRewards.sol";
+import {CommentsTestBase} from "./CommentsTestBase.sol";
+import {UnorderedNoncesUpgradeable} from "@zoralabs/shared-contracts/utils/UnorderedNoncesUpgradeable.sol";
+
+contract CommentsPermitTest is CommentsTestBase {
+    function testPermitComment() public {
+        IComments.PermitComment memory permitComment = _createPermitComment(collectorWithToken, "test comment", 3);
+        bytes memory signature = _signPermitComment(permitComment, collectorWithTokenPrivateKey);
+
+        IComments.CommentIdentifier memory expectedCommentIdentifier = _expectedCommentIdentifier(
+            permitComment.contractAddress,
+            permitComment.tokenId,
+            permitComment.commenter
+        );
+
+        _setupTokenAndSparks(permitComment);
+
+        // any account can execute the permit comment on behalf of the collectorWithToken, but they must have enough eth to do so.
+        address executor = makeAddr("executor");
+        vm.deal(executor, permitComment.sparksQuantity * SPARKS_VALUE);
+
+        vm.expectEmit(true, true, true, true);
+        emit IComments.Commented(
+            comments.hashCommentIdentifier(expectedCommentIdentifier),
+            expectedCommentIdentifier,
+            bytes32(0),
+            permitComment.replyTo,
+            permitComment.sparksQuantity,
+            permitComment.text,
+            block.timestamp,
+            permitComment.referrer
+        );
+
+        _executePermitComment(executor, permitComment, signature);
+
+        _assertCommentExists(expectedCommentIdentifier);
+    }
+
+    function testPermitComment_NonceUsedTwice() public {
+        IComments.PermitComment memory permitComment = _createPermitComment(collectorWithToken, "test comment", 3);
+        bytes memory signature = _signPermitComment(permitComment, collectorWithTokenPrivateKey);
+
+        _setupTokenAndSparks(permitComment);
+
+        // First comment should succeed
+        vm.deal(collectorWithToken, 10 ether);
+        _executePermitComment(collectorWithToken, permitComment, signature);
+
+        // Second comment with same nonce should fail
+        vm.expectRevert(abi.encodeWithSelector(UnorderedNoncesUpgradeable.InvalidAccountNonce.selector, collectorWithToken, permitComment.nonce));
+        _executePermitComment(collectorWithToken, permitComment, signature);
+    }
+
+    function testPermitComment_DeadlineExpired() public {
+        IComments.PermitComment memory permitComment = _createPermitComment(collectorWithToken, "test comment", 3);
+        bytes memory signature = _signPermitComment(permitComment, collectorWithTokenPrivateKey);
+
+        _setupTokenAndSparks(permitComment);
+
+        // Warp time to after the deadline
+        vm.warp(permitComment.deadline + 1);
+
+        address executor = makeAddr("executor");
+        vm.deal(executor, permitComment.sparksQuantity * SPARKS_VALUE);
+        vm.expectRevert(abi.encodeWithSelector(IComments.ERC2612ExpiredSignature.selector, permitComment.deadline));
+        _executePermitComment(executor, permitComment, signature);
+    }
+
+    function testPermitComment_CommenterDoesntMatchSigner() public {
+        address wrongSigner;
+        uint256 wrongSignerPrivateKey;
+        (wrongSigner, wrongSignerPrivateKey) = makeAddrAndKey("wrongSigner");
+
+        IComments.PermitComment memory permitComment = _createPermitComment(collectorWithToken, "test comment", 3);
+        bytes memory wrongSignature = _signPermitComment(permitComment, wrongSignerPrivateKey);
+
+        _setupTokenAndSparks(permitComment);
+
+        vm.expectRevert(IComments.InvalidSignature.selector);
+        _executePermitComment(collectorWithToken, permitComment, wrongSignature);
+    }
+
+    function testPermitComment_ZeroSparks() public {
+        IComments.PermitComment memory permitComment = _createPermitComment(collectorWithToken, "test comment", 0);
+        bytes memory signature = _signPermitComment(permitComment, collectorWithTokenPrivateKey);
+
+        _setupTokenAndSparks(permitComment);
+
+        vm.expectRevert(IComments.MustSendAtLeastOneSpark.selector);
+        _executePermitComment(collectorWithToken, permitComment, signature);
+    }
+
+    function testPermitComment_Not1155Holder() public {
+        IComments.PermitComment memory permitComment = _createPermitComment(collectorWithToken, "test comment", 3);
+        bytes memory signature = _signPermitComment(permitComment, collectorWithTokenPrivateKey);
+
+        address executor = makeAddr("executor");
+        vm.deal(executor, permitComment.sparksQuantity * SPARKS_VALUE);
+        vm.expectRevert(IComments.NotTokenHolderOrAdmin.selector);
+        _executePermitComment(executor, permitComment, signature);
+    }
+
+    function testPermitSparkCommentSparksComment() public {
+        IComments.PermitSparkComment memory permitSparkComment = _postCommentAndCreatePermitSparkComment(sparker, 3);
+        bytes memory signature = _signPermitSparkComment(permitSparkComment, sparkerPrivateKey);
+
+        _setupSparkComment(permitSparkComment);
+
+        address executor = makeAddr("executor");
+        vm.deal(executor, permitSparkComment.sparksQuantity * SPARKS_VALUE);
+
+        bytes32 commentId = comments.hashCommentIdentifier(permitSparkComment.comment);
+
+        uint256 beforeSparksCount = comments.commentSparksQuantity(commentId);
+
+        vm.expectEmit(true, true, true, true);
+        emit IComments.SparkedComment(commentId, permitSparkComment.comment, permitSparkComment.sparksQuantity, sparker, block.timestamp);
+
+        _executePermitSparkComment(executor, permitSparkComment, signature);
+
+        uint256 afterSparksCount = comments.commentSparksQuantity(commentId);
+        assertEq(afterSparksCount, beforeSparksCount + permitSparkComment.sparksQuantity);
+    }
+
+    function testPermitSparkComment_NonceUsedTwice() public {
+        IComments.PermitSparkComment memory permitSparkComment = _postCommentAndCreatePermitSparkComment(sparker, 3);
+        bytes memory signature = _signPermitSparkComment(permitSparkComment, sparkerPrivateKey);
+
+        _setupSparkComment(permitSparkComment);
+
+        // First spark should succeed
+        vm.deal(sparker, 10 ether);
+        _executePermitSparkComment(sparker, permitSparkComment, signature);
+
+        // Second spark with same nonce should fail
+        vm.expectRevert(abi.encodeWithSelector(UnorderedNoncesUpgradeable.InvalidAccountNonce.selector, sparker, permitSparkComment.nonce));
+        _executePermitSparkComment(sparker, permitSparkComment, signature);
+    }
+
+    function testPermitSparkComment_DeadlineExpired() public {
+        IComments.PermitSparkComment memory permitSparkComment = _postCommentAndCreatePermitSparkComment(sparker, 3);
+        bytes memory signature = _signPermitSparkComment(permitSparkComment, sparkerPrivateKey);
+
+        _setupSparkComment(permitSparkComment);
+
+        // Warp time to after the deadline
+        vm.warp(permitSparkComment.deadline + 1);
+
+        address executor = makeAddr("executor");
+        vm.deal(executor, permitSparkComment.sparksQuantity * SPARKS_VALUE);
+        vm.expectRevert(abi.encodeWithSelector(IComments.ERC2612ExpiredSignature.selector, permitSparkComment.deadline));
+        _executePermitSparkComment(executor, permitSparkComment, signature);
+    }
+
+    function testPermitSparkComment_CommenterDoesntMatchSigner() public {
+        address wrongSigner;
+        uint256 wrongSignerPrivateKey;
+        (wrongSigner, wrongSignerPrivateKey) = makeAddrAndKey("wrongSigner");
+
+        IComments.PermitSparkComment memory permitSparkComment = _postCommentAndCreatePermitSparkComment(sparker, 3);
+        bytes memory wrongSignature = _signPermitSparkComment(permitSparkComment, wrongSignerPrivateKey);
+
+        _setupSparkComment(permitSparkComment);
+
+        vm.expectRevert(IComments.InvalidSignature.selector);
+        _executePermitSparkComment(makeAddr("executor"), permitSparkComment, wrongSignature);
+    }
+
+    function testPermitSparkComment_ZeroSparks() public {
+        IComments.PermitSparkComment memory permitSparkComment = _postCommentAndCreatePermitSparkComment(sparker, 0);
+        bytes memory signature = _signPermitSparkComment(permitSparkComment, sparkerPrivateKey);
+
+        _setupSparkComment(permitSparkComment);
+
+        vm.expectRevert(IComments.MustSendAtLeastOneSpark.selector);
+        _executePermitSparkComment(collectorWithToken, permitSparkComment, signature);
+    }
+
+    function testPermitSparkComment_IncorrectETHAmount() public {
+        IComments.PermitSparkComment memory permitSparkComment = _postCommentAndCreatePermitSparkComment(sparker, 3);
+        bytes memory signature = _signPermitSparkComment(permitSparkComment, sparkerPrivateKey);
+
+        _setupSparkComment(permitSparkComment);
+
+        address executor = makeAddr("executor");
+        uint256 incorrectValue = (permitSparkComment.sparksQuantity * SPARKS_VALUE) + 1 wei;
+        vm.deal(executor, incorrectValue);
+
+        vm.expectRevert(
+            abi.encodeWithSelector(IComments.IncorrectETHAmountForSparks.selector, incorrectValue, permitSparkComment.sparksQuantity * SPARKS_VALUE)
+        );
+        vm.prank(executor);
+        comments.permitSparkComment{value: incorrectValue}(permitSparkComment, signature);
+    }
+
+    function testPermitCommentCrossChain() public {
+        uint256 sourceChainId = 1; // Ethereum mainnet
+        uint256 destinationChainId = block.chainid;
+
+        IComments.PermitComment memory permitComment = _createPermitComment(collectorWithToken, "cross-chain comment", 3);
+        permitComment.sourceChainId = sourceChainId;
+        permitComment.destinationChainId = destinationChainId;
+
+        IComments.CommentIdentifier memory expectedCommentIdentifier = _expectedCommentIdentifier(
+            permitComment.contractAddress,
+            permitComment.tokenId,
+            permitComment.commenter
+        );
+
+        bytes memory signature = _signPermitComment(permitComment, collectorWithTokenPrivateKey);
+
+        _setupTokenAndSparks(permitComment);
+
+        address executor = makeAddr("executor");
+        vm.deal(executor, permitComment.sparksQuantity * SPARKS_VALUE);
+
+        vm.expectEmit(true, true, true, true);
+        emit IComments.Commented(
+            comments.hashCommentIdentifier(expectedCommentIdentifier),
+            expectedCommentIdentifier,
+            bytes32(0),
+            permitComment.replyTo,
+            permitComment.sparksQuantity,
+            permitComment.text,
+            block.timestamp,
+            permitComment.referrer
+        );
+
+        _executePermitComment(executor, permitComment, signature);
+
+        _assertCommentExists(expectedCommentIdentifier);
+    }
+
+    function testPermitCommentCrossChainInvalidDestination() public {
+        uint256 sourceChainId = 1; // Ethereum mainnet
+        uint256 invalidDestinationChainId = 42; // Some other chain ID
+
+        IComments.PermitComment memory permitComment = _createPermitComment(collectorWithToken, "invalid cross-chain comment", 3);
+        permitComment.sourceChainId = sourceChainId;
+        permitComment.destinationChainId = invalidDestinationChainId;
+
+        bytes memory signature = _signPermitComment(permitComment, collectorWithTokenPrivateKey);
+
+        _setupTokenAndSparks(permitComment);
+
+        address executor = makeAddr("executor");
+        vm.deal(executor, permitComment.sparksQuantity * SPARKS_VALUE);
+
+        vm.expectRevert(abi.encodeWithSelector(IComments.IncorrectDestinationChain.selector, invalidDestinationChainId));
+        _executePermitComment(executor, permitComment, signature);
+    }
+
+    function testPermitSparkCommentCrossChain() public {
+        uint256 sourceChainId = 1; // Ethereum mainnet
+        uint256 destinationChainId = block.chainid;
+
+        IComments.PermitSparkComment memory permitSparkComment = _postCommentAndCreatePermitSparkComment(sparker, 3);
+        permitSparkComment.sourceChainId = sourceChainId;
+        permitSparkComment.destinationChainId = destinationChainId;
+
+        bytes memory signature = _signPermitSparkComment(permitSparkComment, sparkerPrivateKey);
+
+        _setupSparkComment(permitSparkComment);
+
+        address executor = makeAddr("executor");
+        vm.deal(executor, permitSparkComment.sparksQuantity * SPARKS_VALUE);
+
+        bytes32 commentId = comments.hashCommentIdentifier(permitSparkComment.comment);
+
+        uint256 beforeSparksCount = comments.commentSparksQuantity(commentId);
+
+        vm.expectEmit(true, true, true, true);
+        emit IComments.SparkedComment(commentId, permitSparkComment.comment, permitSparkComment.sparksQuantity, sparker, block.timestamp);
+
+        _executePermitSparkComment(executor, permitSparkComment, signature);
+
+        uint256 afterSparksCount = comments.commentSparksQuantity(commentId);
+        assertEq(afterSparksCount, beforeSparksCount + permitSparkComment.sparksQuantity);
+    }
+
+    function testPermitSparkCommentCrossChainInvalidDestination() public {
+        uint256 sourceChainId = 1; // Ethereum mainnet
+        uint256 invalidDestinationChainId = 42; // Some other chain ID
+
+        IComments.PermitSparkComment memory permitSparkComment = _postCommentAndCreatePermitSparkComment(sparker, 3);
+        permitSparkComment.sourceChainId = sourceChainId;
+        permitSparkComment.destinationChainId = invalidDestinationChainId;
+
+        bytes memory signature = _signPermitSparkComment(permitSparkComment, sparkerPrivateKey);
+
+        _setupSparkComment(permitSparkComment);
+
+        address executor = makeAddr("executor");
+        vm.deal(executor, permitSparkComment.sparksQuantity * SPARKS_VALUE);
+
+        vm.expectRevert(abi.encodeWithSelector(IComments.IncorrectDestinationChain.selector, invalidDestinationChainId));
+        _executePermitSparkComment(executor, permitSparkComment, signature);
+    }
+
+    function _postCommentAndCreatePermitSparkComment(address _sparker, uint64 sparksQuantity) internal returns (IComments.PermitSparkComment memory) {
+        IComments.CommentIdentifier memory emptyReplyTo;
+        address commenter = makeAddr("commenter_b");
+        IComments.CommentIdentifier memory commentIdentifier = _mockComment(commenter, emptyReplyTo);
+
+        return _createPermitSparkComment(commentIdentifier, _sparker, sparksQuantity, block.chainid, block.chainid);
+    }
+
+    // Helper functions
+    function _createPermitSparkComment(
+        IComments.CommentIdentifier memory commentIdentifier,
+        address _sparker,
+        uint64 sparksQuantity,
+        uint256 sourceChainId,
+        uint256 destinationChainId
+    ) internal returns (IComments.PermitSparkComment memory) {
+        return
+            IComments.PermitSparkComment({
+                comment: commentIdentifier,
+                sparker: _sparker,
+                sparksQuantity: sparksQuantity,
+                deadline: block.timestamp + 100,
+                nonce: bytes32("1"),
+                referrer: makeAddr("referrer"),
+                sourceChainId: sourceChainId,
+                destinationChainId: destinationChainId
+            });
+    }
+
+    function _signPermitSparkComment(IComments.PermitSparkComment memory permitSparkComment, uint256 privateKey) internal view returns (bytes memory) {
+        bytes32 digest = comments.hashPermitSparkComment(permitSparkComment);
+        return _sign(privateKey, digest);
+    }
+
+    function _setupSparkComment(IComments.PermitSparkComment memory permitSparkComment) internal {
+        // For permitSparkComment, we don't need to mint a token
+        vm.deal(permitSparkComment.comment.commenter, permitSparkComment.sparksQuantity * SPARKS_VALUE);
+    }
+
+    function _executePermitSparkComment(address executor, IComments.PermitSparkComment memory permitSparkComment, bytes memory signature) internal {
+        vm.prank(executor);
+        vm.deal(executor, permitSparkComment.sparksQuantity * SPARKS_VALUE);
+        comments.permitSparkComment{value: permitSparkComment.sparksQuantity * SPARKS_VALUE}(permitSparkComment, signature);
+    }
+
+    // Helper functions
+    function _createPermitComment(address commenter, string memory text, uint64 sparksQuantity) internal returns (IComments.PermitComment memory) {
+        return
+            IComments.PermitComment({
+                contractAddress: address(mock1155),
+                tokenId: tokenId1,
+                commenter: commenter,
+                replyTo: emptyCommentIdentifier,
+                text: text,
+                sparksQuantity: sparksQuantity,
+                deadline: block.timestamp + 100,
+                nonce: bytes32("1"),
+                referrer: makeAddr("referrer"),
+                sourceChainId: block.chainid,
+                destinationChainId: block.chainid
+            });
+    }
+
+    function _setupTokenAndSparks(IComments.PermitComment memory permitComment) internal {
+        mock1155.mint(permitComment.commenter, permitComment.tokenId, 1, "");
+        vm.deal(permitComment.commenter, permitComment.sparksQuantity * SPARKS_VALUE);
+    }
+
+    function _executePermitComment(address executor, IComments.PermitComment memory permitComment, bytes memory signature) internal {
+        vm.prank(executor);
+        comments.permitComment{value: permitComment.sparksQuantity * SPARKS_VALUE}(permitComment, signature);
+    }
+
+    function _assertCommentExists(IComments.CommentIdentifier memory commentIdentifier) internal view {
+        (, bool exists) = comments.hashAndCheckCommentExists(commentIdentifier);
+        assertTrue(exists);
+    }
+
+    function _signPermitComment(IComments.PermitComment memory permitComment, uint256 privateKey) internal view returns (bytes memory signature) {
+        bytes32 digest = comments.hashPermitComment(permitComment);
+        signature = _sign(privateKey, digest);
+    }
+
+    function _sign(uint256 privateKey, bytes32 digest) internal pure returns (bytes memory signature) {
+        (uint8 v, bytes32 r, bytes32 s) = vm.sign(privateKey, digest);
+        return abi.encodePacked(r, s, v);
+    }
+}

package/test/mocks/Mock1155.sol

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {ERC1155} from "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
+import {IZoraCreator1155} from "../../src/interfaces/IZoraCreator1155.sol";
+
+contract Mock1155 is ERC1155, IZoraCreator1155 {
+    /// @notice This user role allows for any action to be performed
+    uint256 public constant PERMISSION_BIT_ADMIN = 2 ** 1;
+
+    mapping(uint256 => address) public admins;
+
+    constructor() ERC1155("") {}
+
+    function isAdminOrRole(address user, uint256 tokenId, uint256 role) external view returns (bool) {
+        if (admins[tokenId] == user && role == PERMISSION_BIT_ADMIN) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    function _tokenExists(uint256 tokenId) internal view returns (bool) {
+        return admins[tokenId] != address(0);
+    }
+
+    function getCreatorRewardRecipient(uint256 tokenId) external view returns (address) {
+        if (!_tokenExists(tokenId)) {
+            revert("Token does not exist");
+        }
+
+        return admins[tokenId];
+    }
+
+    function createToken(uint256 tokenId, address creator) external {
+        admins[tokenId] = creator;
+    }
+
+    function supportsInterface(bytes4 interfaceId) public view override(ERC1155, IZoraCreator1155) returns (bool) {
+        return super.supportsInterface(interfaceId);
+    }
+
+    function mint(address to, uint256 id, uint256 amount, bytes memory data) external {
+        if (!_tokenExists(id)) {
+            revert("Token does not exist");
+        }
+
+        _mint(to, id, amount, data);
+    }
+}

package/test/mocks/MockMinter.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {Mock1155} from "./Mock1155.sol";
+import {IComments} from "../../src/interfaces/IComments.sol";
+
+contract MockMinter {
+    uint256 MINT_FEE = 0.00111 ether;
+    uint256 constant SPARKS_VALUE = 0.000001 ether;
+
+    IComments immutable comments;
+
+    constructor(IComments _comments) {
+        comments = _comments;
+    }
+
+    IComments.CommentIdentifier internal emptyCommentIdentifier;
+
+    function mintAndComment(uint256 quantity, address collection, uint256 tokenId, string calldata comment) external payable {
+        Mock1155(collection).mint(msg.sender, tokenId, quantity, "");
+
+        // get sparks value to send to comments contract
+        comments.delegateComment(msg.sender, collection, tokenId, comment, emptyCommentIdentifier);
+    }
+
+    function forwardComment(address collection, uint256 tokenId, string calldata comment) external {
+        comments.delegateComment(msg.sender, collection, tokenId, comment, emptyCommentIdentifier);
+    }
+}