@zoralabs/comments-contracts 0.0.1

package/test/Comments.t.sol

@@ -0,0 +1,482 @@
+// 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 {UnorderedNoncesUpgradeable} from "@zoralabs/shared-contracts/utils/UnorderedNoncesUpgradeable.sol";
+import {CommentsTestBase} from "./CommentsTestBase.sol";
+
+contract CommentsTest is CommentsTestBase {
+    uint256 public constant ZORA_REWARD_PCT = 10;
+    uint256 public constant REFERRER_REWARD_PCT = 20;
+    uint256 internal constant BPS_TO_PERCENT_2_DECIMAL_PERCISION = 100;
+
+    function _setupCommenterWithTokenAndSparks(address commenter, uint64 sparksQuantity) internal {
+        vm.startPrank(commenter);
+        mock1155.mint(commenter, tokenId1, 1, "");
+        vm.stopPrank();
+        vm.deal(commenter, sparksQuantity * SPARKS_VALUE);
+    }
+
+    function _createCommentIdentifier(address commenter, bytes32 nonce) internal view returns (IComments.CommentIdentifier memory) {
+        return IComments.CommentIdentifier({commenter: commenter, contractAddress: address(mock1155), tokenId: tokenId1, nonce: nonce});
+    }
+
+    function testCommentContractName() public view {
+        assertEq(comments.contractName(), "Zora Comments");
+    }
+
+    function testCommentWhenCollectorHasTokenShouldEmitCommented() public {
+        vm.startPrank(collectorWithToken);
+        mock1155.mint(collectorWithToken, tokenId1, 1, "");
+        vm.stopPrank();
+
+        vm.deal(collectorWithToken, SPARKS_VALUE);
+
+        address contractAddress = address(mock1155);
+        uint256 tokenId = tokenId1;
+        address commenter = collectorWithToken;
+
+        IComments.CommentIdentifier memory expectedCommentIdentifier = _expectedCommentIdentifier(contractAddress, tokenId, commenter);
+
+        // blank replyTo
+        IComments.CommentIdentifier memory replyTo;
+
+        vm.expectEmit(true, true, true, true);
+        emit IComments.Commented(
+            comments.hashCommentIdentifier(expectedCommentIdentifier),
+            expectedCommentIdentifier,
+            0,
+            replyTo,
+            1,
+            "test comment",
+            block.timestamp,
+            address(0)
+        );
+        vm.prank(collectorWithToken);
+        comments.comment{value: SPARKS_VALUE}(collectorWithToken, contractAddress, tokenId, "test comment", replyTo, address(0));
+
+        uint256 zoraReward = (SPARKS_VALUE * (ZORA_REWARD_PCT + REFERRER_REWARD_PCT)) / BPS_TO_PERCENT_2_DECIMAL_PERCISION;
+        vm.assertEq(protocolRewards.balanceOf(collectorWithToken), 0);
+        vm.assertEq(protocolRewards.balanceOf(zoraRecipient), zoraReward);
+        vm.assertEq(protocolRewards.balanceOf(tokenAdmin), SPARKS_VALUE - zoraReward);
+    }
+
+    function testCommentBackfillBatchAddCommentShouldEmitCommented() public {
+        IComments.CommentIdentifier[] memory commentIdentifiers = new IComments.CommentIdentifier[](2);
+
+        commentIdentifiers[0] = IComments.CommentIdentifier({
+            commenter: makeAddr("commenter1"),
+            contractAddress: address(mock1155),
+            tokenId: tokenId1,
+            nonce: 0
+        });
+
+        commentIdentifiers[1] = IComments.CommentIdentifier({
+            commenter: makeAddr("commenter2"),
+            contractAddress: address(mock1155),
+            tokenId: tokenId2,
+            nonce: bytes32("1")
+        });
+
+        string[] memory texts = new string[](2);
+        texts[0] = "test comment 1";
+        texts[1] = "test comment 2";
+
+        uint256[] memory timestamps = new uint256[](2);
+
+        timestamps[0] = block.timestamp;
+        timestamps[1] = block.timestamp + 100;
+
+        bytes32[] memory originalTransactionHashes = new bytes32[](2);
+        originalTransactionHashes[0] = bytes32("1");
+        originalTransactionHashes[1] = bytes32("2");
+
+        vm.expectEmit(true, true, true, true);
+        // verify first comment is emitted
+        emit IComments.BackfilledComment({
+            commentId: comments.hashCommentIdentifier(commentIdentifiers[0]),
+            comment: commentIdentifiers[0],
+            text: texts[0],
+            timestamp: timestamps[0],
+            originalTransactionId: originalTransactionHashes[0]
+        });
+        vm.expectEmit(true, true, true, true);
+        // verify second comment is emitted
+        emit IComments.BackfilledComment({
+            commentId: comments.hashCommentIdentifier(commentIdentifiers[1]),
+            comment: commentIdentifiers[1],
+            text: texts[1],
+            timestamp: timestamps[1],
+            originalTransactionId: originalTransactionHashes[1]
+        });
+
+        vm.prank(commentsBackfiller);
+        comments.backfillBatchAddComment(commentIdentifiers, texts, timestamps, originalTransactionHashes);
+    }
+
+    function testCommentBackfillBatchAddCommentShouldRevertIfDuplicate() public {
+        IComments.CommentIdentifier[] memory commentIdentifiers = new IComments.CommentIdentifier[](2);
+
+        commentIdentifiers[0] = IComments.CommentIdentifier({
+            commenter: makeAddr("commenter1"),
+            contractAddress: address(mock1155),
+            tokenId: tokenId1,
+            nonce: 0
+        });
+
+        commentIdentifiers[1] = IComments.CommentIdentifier({
+            commenter: makeAddr("commenter2"),
+            contractAddress: address(mock1155),
+            tokenId: tokenId2,
+            nonce: keccak256("1")
+        });
+
+        string[] memory texts = new string[](2);
+        texts[0] = "test comment 1";
+        texts[1] = "test comment 2";
+
+        uint256[] memory timestamps = new uint256[](2);
+
+        timestamps[0] = block.timestamp;
+        timestamps[1] = block.timestamp + 100;
+
+        bytes32[] memory originalTransactionHashes = new bytes32[](2);
+        originalTransactionHashes[0] = bytes32("1");
+        originalTransactionHashes[1] = bytes32("2");
+
+        vm.prank(commentsBackfiller);
+        comments.backfillBatchAddComment(commentIdentifiers, texts, timestamps, originalTransactionHashes);
+
+        // ensure that when backfilling a duplicate, it reverts
+        vm.expectRevert(abi.encodeWithSelector(IComments.DuplicateComment.selector, comments.hashCommentIdentifier(commentIdentifiers[0])));
+        vm.prank(commentsBackfiller);
+        comments.backfillBatchAddComment(commentIdentifiers, texts, timestamps, originalTransactionHashes);
+    }
+
+    function testCommentBackfillBatchAddCommentShouldRevertIfArrayLengthMismatch() public {
+        IComments.CommentIdentifier[] memory commentIdentifiers = new IComments.CommentIdentifier[](2);
+        commentIdentifiers[1] = commentIdentifiers[0];
+
+        string[] memory texts = new string[](2);
+
+        uint256[] memory timestamps = new uint256[](1); // Mismatched length
+
+        bytes32[] memory originalTransactionHashes = new bytes32[](2);
+
+        vm.expectRevert(IComments.ArrayLengthMismatch.selector);
+        vm.prank(commentsBackfiller);
+        comments.backfillBatchAddComment(commentIdentifiers, texts, timestamps, originalTransactionHashes);
+    }
+
+    function testCommentSparkCommentWithZeroSparks() public {
+        IComments.CommentIdentifier memory commentIdentifier = IComments.CommentIdentifier({
+            commenter: collectorWithToken,
+            contractAddress: address(mock1155),
+            tokenId: tokenId1,
+            nonce: bytes32(0)
+        });
+        vm.expectRevert(abi.encodeWithSignature("MustSendAtLeastOneSpark()"));
+        comments.sparkComment(commentIdentifier, 0, address(0));
+    }
+
+    function testCommentSparkCommentWithInvalidAmount() public {
+        IComments.CommentIdentifier memory commentIdentifier = IComments.CommentIdentifier({
+            commenter: collectorWithToken,
+            contractAddress: address(mock1155),
+            tokenId: tokenId1,
+            nonce: bytes32(0)
+        });
+        vm.expectRevert(abi.encodeWithSelector(IComments.IncorrectETHAmountForSparks.selector, 0, SPARKS_VALUE));
+        comments.sparkComment{value: 0}(commentIdentifier, 1, address(0));
+    }
+
+    function testCommentSparkCommentOwnComment() public {
+        // comment
+        IComments.CommentIdentifier memory replyTo;
+        IComments.CommentIdentifier memory commentIdentifier = _mockComment(collectorWithToken, replyTo);
+
+        // spark own comment
+        vm.deal(collectorWithToken, SPARKS_VALUE);
+
+        vm.expectRevert(abi.encodeWithSignature("CannotSparkOwnComment()"));
+        vm.prank(collectorWithToken);
+        comments.sparkComment{value: SPARKS_VALUE}(commentIdentifier, 1, address(0));
+    }
+
+    function testCommentSparkCommentDoesNotExist() public {
+        IComments.CommentIdentifier memory commentIdentifier = IComments.CommentIdentifier({
+            commenter: collectorWithToken,
+            contractAddress: address(mock1155),
+            tokenId: tokenId1,
+            nonce: keccak256("123456")
+        });
+        vm.expectRevert(abi.encodeWithSignature("CommentDoesntExist()"));
+        comments.sparkComment{value: SPARKS_VALUE}(commentIdentifier, 1, address(0));
+    }
+
+    function testCommentSparkCommentValid(uint64 sparksQuantity) public {
+        vm.assume(sparksQuantity > 0 && sparksQuantity < 1_000_000_000_000_000);
+
+        // comment
+        IComments.CommentIdentifier memory replyTo;
+        IComments.CommentIdentifier memory commentIdentifier = _mockComment(collectorWithToken, replyTo);
+
+        // mint
+        address commentor2 = makeAddr("commentor2");
+
+        uint256 zoraRecipientBalanceBeforeSpark = protocolRewards.balanceOf(zoraRecipient);
+
+        // spark comment
+        vm.deal(commentor2, sparksQuantity * SPARKS_VALUE);
+
+        vm.expectEmit(true, true, true, true);
+        emit IComments.SparkedComment(comments.hashCommentIdentifier(commentIdentifier), commentIdentifier, sparksQuantity, commentor2, block.timestamp);
+        vm.prank(commentor2);
+        comments.sparkComment{value: sparksQuantity * SPARKS_VALUE}(commentIdentifier, sparksQuantity, address(0));
+
+        uint256 zoraReward = (sparksQuantity * SPARKS_VALUE * (ZORA_REWARD_PCT + REFERRER_REWARD_PCT)) / BPS_TO_PERCENT_2_DECIMAL_PERCISION;
+        vm.assertEq(protocolRewards.balanceOf(zoraRecipient) - zoraRecipientBalanceBeforeSpark, zoraReward);
+        vm.assertEq(protocolRewards.balanceOf(collectorWithToken), (sparksQuantity * SPARKS_VALUE) - zoraReward);
+    }
+
+    function testCommentSparkCommentValidWithReferrer(uint64 sparksQuantity) public {
+        vm.assume(sparksQuantity > 0 && sparksQuantity < 1_000_000_000_000_000);
+
+        // comment
+        IComments.CommentIdentifier memory replyTo;
+        IComments.CommentIdentifier memory commentIdentifier = _mockComment(collectorWithToken, replyTo);
+
+        // mint
+        address commentor2 = makeAddr("commentor2");
+
+        uint256 zoraRecipientBalanceBeforeSpark = protocolRewards.balanceOf(zoraRecipient);
+
+        // spark comment
+        vm.deal(commentor2, sparksQuantity * SPARKS_VALUE);
+
+        address referrer = makeAddr("referrer");
+
+        vm.expectEmit(true, true, true, true);
+        emit IComments.SparkedComment(comments.hashCommentIdentifier(commentIdentifier), commentIdentifier, sparksQuantity, commentor2, block.timestamp);
+        vm.prank(commentor2);
+        comments.sparkComment{value: sparksQuantity * SPARKS_VALUE}(commentIdentifier, sparksQuantity, referrer);
+
+        uint256 zoraReward = (sparksQuantity * SPARKS_VALUE * ZORA_REWARD_PCT) / BPS_TO_PERCENT_2_DECIMAL_PERCISION;
+        uint256 referrerReward = (sparksQuantity * SPARKS_VALUE * REFERRER_REWARD_PCT) / BPS_TO_PERCENT_2_DECIMAL_PERCISION;
+        vm.assertEq(protocolRewards.balanceOf(zoraRecipient) - zoraRecipientBalanceBeforeSpark, zoraReward);
+        vm.assertEq(protocolRewards.balanceOf(referrer), referrerReward);
+        vm.assertEq(protocolRewards.balanceOf(collectorWithToken), (sparksQuantity * SPARKS_VALUE) - zoraReward - referrerReward);
+    }
+
+    function testCommentHashAndValidateCommentExists() public {
+        IComments.CommentIdentifier memory commentIdentifier = IComments.CommentIdentifier({
+            commenter: collectorWithToken,
+            contractAddress: address(mock1155),
+            tokenId: tokenId1,
+            nonce: keccak256("123456")
+        });
+        vm.expectRevert(abi.encodeWithSignature("CommentDoesntExist()"));
+        comments.hashAndValidateCommentExists(commentIdentifier);
+    }
+
+    function postComment(
+        address commenter,
+        address contractAddress,
+        uint256 tokenId,
+        string memory content,
+        IComments.CommentIdentifier memory replyTo
+    ) internal returns (IComments.CommentIdentifier memory) {
+        vm.prank(commenter);
+        return comments.comment{value: SPARKS_VALUE}(commenter, contractAddress, tokenId, content, replyTo, address(0));
+    }
+
+    function testHashAndCheckCommentExists() public {
+        address commenter = collectorWithToken;
+        address contractAddress = address(mock1155);
+        uint256 tokenId = tokenId1;
+
+        // Check that the comment doesn't exist initially
+        (bytes32 commentId, bool exists) = comments.hashAndCheckCommentExists(_expectedCommentIdentifier(contractAddress, tokenId, commenter));
+        assertFalse(exists);
+
+        // Setup and post comment
+        _setupCommenterWithTokenAndSparks(commenter, 1);
+        IComments.CommentIdentifier memory postedCommentIdentifier = postComment(commenter, contractAddress, tokenId, "test comment", emptyCommentIdentifier);
+
+        // Check that the comment now exists
+        (bytes32 newCommentId, bool newExists) = comments.hashAndCheckCommentExists(postedCommentIdentifier);
+        assertTrue(newExists);
+        assertEq(commentId, newCommentId);
+        assertEq(comments.hashCommentIdentifier(postedCommentIdentifier), newCommentId);
+    }
+
+    function testReplyToNonExistentComment() public {
+        address commentor = makeAddr("commentor");
+        _setupCommenterWithTokenAndSparks(commentor, 1);
+
+        IComments.CommentIdentifier memory nonExistentReplyTo = IComments.CommentIdentifier({
+            commenter: makeAddr("nonExistentCommenter"),
+            contractAddress: address(mock1155),
+            tokenId: tokenId1,
+            nonce: keccak256("nonExistentNonce")
+        });
+
+        vm.expectRevert(IComments.CommentDoesntExist.selector);
+        postComment(commentor, address(mock1155), tokenId1, "Replying to non-existent comment", nonExistentReplyTo);
+    }
+
+    function testReplyToCommentThatAddressDoesNotMatch() public {
+        address originalCommenter = makeAddr("originalCommenter");
+        address replier = makeAddr("replier");
+
+        _setupCommenterWithTokenAndSparks(originalCommenter, 1);
+        _setupCommenterWithTokenAndSparks(replier, 1);
+
+        IComments.CommentIdentifier memory originalCommentIdentifier = postComment(
+            originalCommenter,
+            address(mock1155),
+            tokenId1,
+            "Original comment",
+            emptyCommentIdentifier
+        );
+
+        // mismatched address
+        address mismatchedAddress = makeAddr("xyz");
+
+        vm.expectRevert(
+            abi.encodeWithSelector(IComments.CommentAddressOrTokenIdsDoNotMatch.selector, mismatchedAddress, tokenId1, address(mock1155), tokenId1)
+        );
+        vm.prank(replier);
+        comments.comment{value: SPARKS_VALUE}(replier, mismatchedAddress, tokenId1, "Reply to original comment", originalCommentIdentifier, address(0));
+
+        // mismatched tokenId
+        uint256 mismatchedTokenId = 123;
+
+        vm.expectRevert(
+            abi.encodeWithSelector(IComments.CommentAddressOrTokenIdsDoNotMatch.selector, address(mock1155), mismatchedTokenId, address(mock1155), tokenId1)
+        );
+        vm.prank(replier);
+        comments.comment{value: SPARKS_VALUE}(
+            replier,
+            address(mock1155),
+            mismatchedTokenId,
+            "Reply to original comment",
+            originalCommentIdentifier,
+            address(0)
+        );
+    }
+
+    function testReplyToExistingComment() public {
+        address originalCommenter = makeAddr("originalCommenter");
+        address replier = makeAddr("replier");
+
+        _setupCommenterWithTokenAndSparks(originalCommenter, 1);
+        _setupCommenterWithTokenAndSparks(replier, 1);
+
+        IComments.CommentIdentifier memory originalCommentIdentifier = postComment(
+            originalCommenter,
+            address(mock1155),
+            tokenId1,
+            "Original comment",
+            emptyCommentIdentifier
+        );
+
+        IComments.CommentIdentifier memory expectedReplyCommentIdentifier = _expectedCommentIdentifier(address(mock1155), tokenId1, replier);
+
+        vm.expectEmit(true, true, true, true);
+        emit IComments.Commented(
+            comments.hashCommentIdentifier(expectedReplyCommentIdentifier),
+            expectedReplyCommentIdentifier,
+            comments.hashCommentIdentifier(originalCommentIdentifier),
+            originalCommentIdentifier,
+            1,
+            "Reply to original comment",
+            block.timestamp,
+            address(0)
+        );
+
+        IComments.CommentIdentifier memory replyCommentIdentifier = postComment(
+            replier,
+            address(mock1155),
+            tokenId1,
+            "Reply to original comment",
+            originalCommentIdentifier
+        );
+
+        assertEq(payable(address(comments)).balance, 0, "comments contract should have no balance");
+
+        uint64 commenteeSparks = comments.commentSparksQuantity(comments.hashCommentIdentifier(originalCommentIdentifier));
+        assertEq(commenteeSparks, 0, "commentee sparks should be 0");
+
+        assertEq(protocolRewards.balanceOf(originalCommenter), (SPARKS_VALUE * 70) / 100, "rewards mismatch");
+
+        (, bool exists) = comments.hashAndCheckCommentExists(replyCommentIdentifier);
+        assertTrue(exists);
+    }
+
+    function testCommentMismatchedCommenter() public {
+        address actualCommenter = makeAddr("actualCommenter");
+        address mismatchedCommenter = makeAddr("mismatchedCommenter");
+
+        _setupCommenterWithTokenAndSparks(actualCommenter, 1);
+
+        vm.expectRevert(abi.encodeWithSelector(IComments.CommenterMismatch.selector, mismatchedCommenter, actualCommenter));
+        vm.prank(actualCommenter);
+        comments.comment{value: SPARKS_VALUE}(mismatchedCommenter, address(mock1155), tokenId1, "Mismatched commenter", emptyCommentIdentifier, address(0));
+    }
+
+    function testRevertOnEmptyComment() public {
+        address commenter = makeAddr("commenter");
+        _setupCommenterWithTokenAndSparks(commenter, 1);
+
+        vm.expectRevert(IComments.EmptyComment.selector);
+        postComment(commenter, address(mock1155), tokenId1, "", emptyCommentIdentifier);
+    }
+
+    function testRevertOnNotTokenHolderOrAdmin() public {
+        address nonHolder = makeAddr("nonHolder");
+
+        // We don't set up the commenter with a token, so they're neither a holder nor an admin
+        vm.deal(nonHolder, SPARKS_VALUE);
+
+        vm.expectRevert(IComments.NotTokenHolderOrAdmin.selector);
+        postComment(nonHolder, address(mock1155), tokenId1, "Attempting to comment without holding token", emptyCommentIdentifier);
+    }
+
+    function testCommentRevertsWhenSendTooMuchValue() public {
+        address tokenHolder = makeAddr("tokenHolder");
+
+        _setupCommenterWithTokenAndSparks(tokenHolder, 1);
+
+        vm.deal(tokenHolder, 1 ether);
+        vm.prank(tokenHolder);
+        vm.expectRevert(abi.encodeWithSelector(IComments.IncorrectETHAmountForSparks.selector, 1 ether, SPARKS_VALUE));
+        comments.comment{value: 1 ether}(tokenHolder, address(mock1155), tokenId1, "test", emptyCommentIdentifier, address(0));
+    }
+
+    function testCommentRevertsWhenSendTooLittleValue() public {
+        address tokenHolder = makeAddr("tokenHolder");
+
+        _setupCommenterWithTokenAndSparks(tokenHolder, 1);
+
+        vm.prank(tokenHolder);
+        vm.expectRevert(abi.encodeWithSelector(IComments.MustSendAtLeastOneSpark.selector));
+        comments.comment(tokenHolder, address(mock1155), tokenId1, "test", emptyCommentIdentifier, address(0));
+    }
+
+    function testCommentRevertsWhenSendExactValue() public {
+        address tokenHolder = makeAddr("tokenHolder");
+
+        _setupCommenterWithTokenAndSparks(tokenHolder, 1);
+
+        vm.prank(tokenHolder);
+        comments.comment{value: SPARKS_VALUE}(tokenHolder, address(mock1155), tokenId1, "test", emptyCommentIdentifier, address(0));
+    }
+}

package/test/CommentsTestBase.sol

@@ -0,0 +1,86 @@
+// 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";
+
+contract CommentsTestBase is Test {
+    CommentsImpl internal comments;
+    Mock1155 internal mock1155;
+
+    uint256 internal constant SPARKS_VALUE = 0.000001 ether;
+
+    IComments.CommentIdentifier internal emptyCommentIdentifier;
+    ProtocolRewards internal protocolRewards;
+
+    address internal commentsAdmin = makeAddr("commentsAdmin");
+    address internal commentsBackfiller = makeAddr("commentsBackfiller");
+    address internal zoraRecipient = makeAddr("zoraRecipient");
+    address internal tokenAdmin = makeAddr("tokenCreator");
+    address internal collectorWithToken;
+    uint256 internal collectorWithTokenPrivateKey;
+    address internal collectorWithoutToken = makeAddr("collectorWithoutToken");
+    address internal sparker;
+    uint256 internal sparkerPrivateKey;
+
+    uint256 internal tokenId1 = 1;
+    uint256 internal tokenId2 = 2;
+
+    function setUp() public {
+        protocolRewards = new ProtocolRewards();
+        CommentsImpl commentsImpl = new CommentsImpl(SPARKS_VALUE, address(protocolRewards));
+
+        // initialze empty delegateCommenters array
+        address[] memory delegateCommenters = new address[](0);
+
+        // intialize proxy
+        comments = CommentsImpl(payable(address(new Comments(address(commentsImpl)))));
+        comments.initialize({
+            _zoraRecipient: zoraRecipient,
+            defaultAdmin: commentsAdmin,
+            backfiller: commentsBackfiller,
+            delegateCommenters: delegateCommenters
+        });
+
+        mock1155 = new Mock1155();
+
+        mock1155.createToken(tokenId1, tokenAdmin);
+        mock1155.createToken(tokenId2, tokenAdmin);
+
+        (collectorWithToken, collectorWithTokenPrivateKey) = makeAddrAndKey("collectorWithToken");
+        (sparker, sparkerPrivateKey) = makeAddrAndKey("sparker");
+
+        mock1155 = new Mock1155();
+
+        mock1155.createToken(tokenId1, tokenAdmin);
+        mock1155.createToken(tokenId2, tokenAdmin);
+    }
+
+    function _expectedCommentIdentifier(
+        address contractAddress,
+        uint256 tokenId,
+        address commenter
+    ) internal view returns (IComments.CommentIdentifier memory) {
+        return IComments.CommentIdentifier({commenter: commenter, contractAddress: contractAddress, tokenId: tokenId, nonce: comments.nextNonce()});
+    }
+
+    function _mockComment(
+        address commentor,
+        IComments.CommentIdentifier memory replyTo
+    ) internal returns (IComments.CommentIdentifier memory commentIdentifier) {
+        vm.startPrank(commentor);
+        mock1155.mint(commentor, tokenId1, 1, "");
+        vm.stopPrank();
+
+        vm.deal(commentor, SPARKS_VALUE);
+
+        vm.prank(commentor);
+        commentIdentifier = comments.comment{value: SPARKS_VALUE}(commentor, address(mock1155), tokenId1, "comment", replyTo, address(0));
+    }
+}

package/test/Comments_mintAndComment.t.sol

@@ -0,0 +1,101 @@
+// 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 {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
+import {MockMinter} from "./mocks/MockMinter.sol";
+
+contract Comments_mintAndCommentTest is Test {
+    Mock1155 mock1155;
+    CommentsImpl comments;
+
+    uint256 constant SPARKS_VALUE = 0.000001 ether;
+
+    address zoraRecipient = makeAddr("zoraRecipient");
+    address commentsAdmin = makeAddr("commentsAdmin");
+    address commentor = makeAddr("commentor");
+    address tokenAdmin = makeAddr("tokenAdmin");
+
+    uint256 tokenId1 = 1;
+
+    address constant protocolRewards = 0x7777777F279eba3d3Ad8F4E708545291A6fDBA8B;
+    MockMinter mockMinter;
+
+    function setUp() public {
+        vm.createSelectFork("zora_sepolia", 14562731);
+
+        CommentsImpl commentsImpl = new CommentsImpl(SPARKS_VALUE, protocolRewards);
+
+        comments = CommentsImpl(payable(address(new Comments(address(commentsImpl)))));
+
+        // create mock minter, which will mint and comment on the comments contract.
+        // mock minter will be granted permission to do a delegateComment on the comments contract
+        mockMinter = new MockMinter(IComments(address(comments)));
+        address[] memory delegateCommenters = new address[](1);
+        delegateCommenters[0] = address(mockMinter);
+
+        comments.initialize({_zoraRecipient: zoraRecipient, defaultAdmin: commentsAdmin, backfiller: address(0), delegateCommenters: delegateCommenters});
+
+        mock1155 = new Mock1155();
+
+        mock1155.createToken(tokenId1, tokenAdmin);
+    }
+
+    function _expectedCommentIdentifier(
+        address commenter,
+        address contractAddress,
+        uint256 tokenId
+    ) internal view returns (IComments.CommentIdentifier memory) {
+        return IComments.CommentIdentifier({commenter: commenter, contractAddress: contractAddress, tokenId: tokenId, nonce: comments.nextNonce()});
+    }
+
+    function testCanMintAndCommentWithNoSparks() public {
+        uint256 quantityToMint = 1;
+        uint256 mintFee = 0.000111 ether;
+
+        address commenter = commentor;
+        address contractAddress = address(mock1155);
+        uint256 tokenId = tokenId1;
+
+        IComments.CommentIdentifier memory emptyReplyTo;
+
+        IComments.CommentIdentifier memory expectedCommentIdentifier = _expectedCommentIdentifier(commenter, contractAddress, tokenId);
+
+        bytes32 expectedCommentId = comments.hashCommentIdentifier(expectedCommentIdentifier);
+        bytes32 expectedReplyToId = bytes32(0);
+
+        uint64 sparksQuantity = 0;
+
+        vm.deal(commentor, mintFee * quantityToMint);
+        vm.expectEmit(true, true, true, true);
+        emit IComments.Commented(
+            expectedCommentId,
+            _expectedCommentIdentifier(commenter, contractAddress, tokenId),
+            expectedReplyToId,
+            emptyReplyTo,
+            sparksQuantity,
+            "test",
+            block.timestamp,
+            address(0)
+        );
+        vm.prank(commentor);
+        mockMinter.mintAndComment(quantityToMint, address(mock1155), tokenId1, "test");
+
+        // validate that the comment was created
+        (, bool exists) = comments.hashAndCheckCommentExists(expectedCommentIdentifier);
+        assertEq(exists, true);
+    }
+
+    function test_delegateComment_revertsWhenNotOwnerOrCreator() public {
+        address notOwner = makeAddr("notOwner");
+        vm.prank(notOwner);
+        vm.expectRevert(IComments.NotTokenHolderOrAdmin.selector);
+        mockMinter.forwardComment(address(mock1155), tokenId1, "test");
+    }
+}