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

package/test/Comments.t.sol

@@ -3,21 +3,20 @@ 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";
+import {Mock1155NoCreatorRewardRecipient} from "./mocks/Mock1155NoCreatorRewardRecipient.sol";
+import {Mock1155NoOwner} from "./mocks/Mock1155NoOwner.sol";
+import {CommentsImpl} from "../src/CommentsImpl.sol";
+import {Comments} from "../src/proxy/Comments.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 {
+    function _setupCommenterWithTokenAndSparks(address commenter, uint256 sparksQuantity) internal {
         vm.startPrank(commenter);
         mock1155.mint(commenter, tokenId1, 1, "");
         vm.stopPrank();
@@ -60,7 +59,7 @@ contract CommentsTest is CommentsTestBase {
             address(0)
         );
         vm.prank(collectorWithToken);
-        comments.comment{value: SPARKS_VALUE}(collectorWithToken, contractAddress, tokenId, "test comment", replyTo, address(0));
+        comments.comment{value: SPARKS_VALUE}(collectorWithToken, contractAddress, tokenId, "test comment", replyTo, address(0), address(0));
 
         uint256 zoraReward = (SPARKS_VALUE * (ZORA_REWARD_PCT + REFERRER_REWARD_PCT)) / BPS_TO_PERCENT_2_DECIMAL_PERCISION;
         vm.assertEq(protocolRewards.balanceOf(collectorWithToken), 0);
@@ -102,7 +101,7 @@ contract CommentsTest is CommentsTestBase {
         // verify first comment is emitted
         emit IComments.BackfilledComment({
             commentId: comments.hashCommentIdentifier(commentIdentifiers[0]),
-            comment: commentIdentifiers[0],
+            commentIdentifier: commentIdentifiers[0],
             text: texts[0],
             timestamp: timestamps[0],
             originalTransactionId: originalTransactionHashes[0]
@@ -111,7 +110,7 @@ contract CommentsTest is CommentsTestBase {
         // verify second comment is emitted
         emit IComments.BackfilledComment({
             commentId: comments.hashCommentIdentifier(commentIdentifiers[1]),
-            comment: commentIdentifiers[1],
+            commentIdentifier: commentIdentifiers[1],
             text: texts[1],
             timestamp: timestamps[1],
             originalTransactionId: originalTransactionHashes[1]
@@ -221,7 +220,7 @@ contract CommentsTest is CommentsTestBase {
         comments.sparkComment{value: SPARKS_VALUE}(commentIdentifier, 1, address(0));
     }
 
-    function testCommentSparkCommentValid(uint64 sparksQuantity) public {
+    function testCommentSparkCommentValid(uint256 sparksQuantity) public {
         vm.assume(sparksQuantity > 0 && sparksQuantity < 1_000_000_000_000_000);
 
         // comment
@@ -229,16 +228,23 @@ contract CommentsTest is CommentsTestBase {
         IComments.CommentIdentifier memory commentIdentifier = _mockComment(collectorWithToken, replyTo);
 
         // mint
-        address commentor2 = makeAddr("commentor2");
+        address commenter2 = makeAddr("commenter2");
 
         uint256 zoraRecipientBalanceBeforeSpark = protocolRewards.balanceOf(zoraRecipient);
 
         // spark comment
-        vm.deal(commentor2, sparksQuantity * SPARKS_VALUE);
+        vm.deal(commenter2, sparksQuantity * SPARKS_VALUE);
 
         vm.expectEmit(true, true, true, true);
-        emit IComments.SparkedComment(comments.hashCommentIdentifier(commentIdentifier), commentIdentifier, sparksQuantity, commentor2, block.timestamp);
-        vm.prank(commentor2);
+        emit IComments.SparkedComment(
+            comments.hashCommentIdentifier(commentIdentifier),
+            commentIdentifier,
+            sparksQuantity,
+            commenter2,
+            block.timestamp,
+            address(0)
+        );
+        vm.prank(commenter2);
         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;
@@ -246,7 +252,7 @@ contract CommentsTest is CommentsTestBase {
         vm.assertEq(protocolRewards.balanceOf(collectorWithToken), (sparksQuantity * SPARKS_VALUE) - zoraReward);
     }
 
-    function testCommentSparkCommentValidWithReferrer(uint64 sparksQuantity) public {
+    function testCommentSparkCommentValidWithReferrer(uint256 sparksQuantity) public {
         vm.assume(sparksQuantity > 0 && sparksQuantity < 1_000_000_000_000_000);
 
         // comment
@@ -254,18 +260,25 @@ contract CommentsTest is CommentsTestBase {
         IComments.CommentIdentifier memory commentIdentifier = _mockComment(collectorWithToken, replyTo);
 
         // mint
-        address commentor2 = makeAddr("commentor2");
+        address commenter2 = makeAddr("commenter2");
 
         uint256 zoraRecipientBalanceBeforeSpark = protocolRewards.balanceOf(zoraRecipient);
 
         // spark comment
-        vm.deal(commentor2, sparksQuantity * SPARKS_VALUE);
+        vm.deal(commenter2, 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);
+        emit IComments.SparkedComment(
+            comments.hashCommentIdentifier(commentIdentifier),
+            commentIdentifier,
+            sparksQuantity,
+            commenter2,
+            block.timestamp,
+            referrer
+        );
+        vm.prank(commenter2);
         comments.sparkComment{value: sparksQuantity * SPARKS_VALUE}(commentIdentifier, sparksQuantity, referrer);
 
         uint256 zoraReward = (sparksQuantity * SPARKS_VALUE * ZORA_REWARD_PCT) / BPS_TO_PERCENT_2_DECIMAL_PERCISION;
@@ -294,7 +307,7 @@ contract CommentsTest is CommentsTestBase {
         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));
+        return comments.comment{value: SPARKS_VALUE}(commenter, contractAddress, tokenId, content, replyTo, address(0), address(0));
     }
 
     function testHashAndCheckCommentExists() public {
@@ -318,8 +331,8 @@ contract CommentsTest is CommentsTestBase {
     }
 
     function testReplyToNonExistentComment() public {
-        address commentor = makeAddr("commentor");
-        _setupCommenterWithTokenAndSparks(commentor, 1);
+        address commenter = makeAddr("commenter");
+        _setupCommenterWithTokenAndSparks(commenter, 1);
 
         IComments.CommentIdentifier memory nonExistentReplyTo = IComments.CommentIdentifier({
             commenter: makeAddr("nonExistentCommenter"),
@@ -329,7 +342,7 @@ contract CommentsTest is CommentsTestBase {
         });
 
         vm.expectRevert(IComments.CommentDoesntExist.selector);
-        postComment(commentor, address(mock1155), tokenId1, "Replying to non-existent comment", nonExistentReplyTo);
+        postComment(commenter, address(mock1155), tokenId1, "Replying to non-existent comment", nonExistentReplyTo);
     }
 
     function testReplyToCommentThatAddressDoesNotMatch() public {
@@ -354,7 +367,15 @@ contract CommentsTest is CommentsTestBase {
             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));
+        comments.comment{value: SPARKS_VALUE}(
+            replier,
+            mismatchedAddress,
+            tokenId1,
+            "Reply to original comment",
+            originalCommentIdentifier,
+            address(0),
+            address(0)
+        );
 
         // mismatched tokenId
         uint256 mismatchedTokenId = 123;
@@ -369,6 +390,7 @@ contract CommentsTest is CommentsTestBase {
             mismatchedTokenId,
             "Reply to original comment",
             originalCommentIdentifier,
+            address(0),
             address(0)
         );
     }
@@ -412,7 +434,7 @@ contract CommentsTest is CommentsTestBase {
 
         assertEq(payable(address(comments)).balance, 0, "comments contract should have no balance");
 
-        uint64 commenteeSparks = comments.commentSparksQuantity(comments.hashCommentIdentifier(originalCommentIdentifier));
+        uint256 commenteeSparks = comments.commentSparksQuantity(originalCommentIdentifier);
         assertEq(commenteeSparks, 0, "commentee sparks should be 0");
 
         assertEq(protocolRewards.balanceOf(originalCommenter), (SPARKS_VALUE * 70) / 100, "rewards mismatch");
@@ -429,7 +451,15 @@ contract CommentsTest is CommentsTestBase {
 
         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));
+        comments.comment{value: SPARKS_VALUE}(
+            mismatchedCommenter,
+            address(mock1155),
+            tokenId1,
+            "Mismatched commenter",
+            emptyCommentIdentifier,
+            address(0),
+            address(0)
+        );
     }
 
     function testRevertOnEmptyComment() public {
@@ -458,7 +488,7 @@ contract CommentsTest is CommentsTestBase {
         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));
+        comments.comment{value: 1 ether}(tokenHolder, address(mock1155), tokenId1, "test", emptyCommentIdentifier, address(0), address(0));
     }
 
     function testCommentRevertsWhenSendTooLittleValue() public {
@@ -468,7 +498,7 @@ contract CommentsTest is CommentsTestBase {
 
         vm.prank(tokenHolder);
         vm.expectRevert(abi.encodeWithSelector(IComments.MustSendAtLeastOneSpark.selector));
-        comments.comment(tokenHolder, address(mock1155), tokenId1, "test", emptyCommentIdentifier, address(0));
+        comments.comment(tokenHolder, address(mock1155), tokenId1, "test", emptyCommentIdentifier, address(0), address(0));
     }
 
     function testCommentRevertsWhenSendExactValue() public {
@@ -477,6 +507,113 @@ contract CommentsTest is CommentsTestBase {
         _setupCommenterWithTokenAndSparks(tokenHolder, 1);
 
         vm.prank(tokenHolder);
-        comments.comment{value: SPARKS_VALUE}(tokenHolder, address(mock1155), tokenId1, "test", emptyCommentIdentifier, address(0));
+        comments.comment{value: SPARKS_VALUE}(tokenHolder, address(mock1155), tokenId1, "test", emptyCommentIdentifier, address(0), address(0));
+    }
+
+    function testCommentWithMock1155NoCreatorRewardRecipient() public {
+        Mock1155NoCreatorRewardRecipient mock1155NoCreatorRewardRecipient = new Mock1155NoCreatorRewardRecipient();
+        mock1155NoCreatorRewardRecipient.createToken(tokenId1, tokenAdmin);
+
+        vm.startPrank(collectorWithToken);
+        mock1155NoCreatorRewardRecipient.mint(collectorWithToken, tokenId1, 1, "");
+        vm.stopPrank();
+
+        uint256 sparksQuantity = 1;
+
+        vm.deal(collectorWithToken, sparksQuantity * SPARKS_VALUE);
+
+        address contractAddress = address(mock1155NoCreatorRewardRecipient);
+        uint256 tokenId = tokenId1;
+
+        // blank replyTo
+        IComments.CommentIdentifier memory replyTo;
+
+        // funds recipient is 0x000...
+        vm.prank(collectorWithToken);
+        vm.expectRevert(abi.encodeWithSelector(IComments.NoFundsRecipient.selector));
+        comments.comment{value: sparksQuantity * SPARKS_VALUE}(collectorWithToken, contractAddress, tokenId, "test comment", replyTo, address(0), address(0));
+
+        // with funds recipient set
+        address newFundsRecipient = makeAddr("newFundsRecipient");
+        mock1155NoCreatorRewardRecipient.setFundsRecipient(payable(newFundsRecipient));
+        vm.deal(collectorWithToken, sparksQuantity * SPARKS_VALUE);
+
+        vm.prank(collectorWithToken);
+        comments.comment{value: sparksQuantity * SPARKS_VALUE}(
+            collectorWithToken,
+            contractAddress,
+            tokenId,
+            "test comment with recipient",
+            replyTo,
+            address(0),
+            address(0)
+        );
+
+        uint256 zoraReward = (sparksQuantity * SPARKS_VALUE * (ZORA_REWARD_PCT + REFERRER_REWARD_PCT)) / BPS_TO_PERCENT_2_DECIMAL_PERCISION;
+        uint256 recipientReward = (sparksQuantity * SPARKS_VALUE) - zoraReward;
+        vm.assertEq(protocolRewards.balanceOf(newFundsRecipient), recipientReward);
+    }
+
+    function testCommentWithMock1155NoOwner() public {
+        Mock1155NoOwner mock1155NoOwner = new Mock1155NoOwner();
+        mock1155NoOwner.createToken(tokenId1, tokenAdmin);
+
+        vm.startPrank(collectorWithToken);
+        mock1155NoOwner.mint(collectorWithToken, tokenId1, 1, "");
+        vm.stopPrank();
+
+        uint256 sparksQuantity = 1;
+        vm.deal(collectorWithToken, sparksQuantity * SPARKS_VALUE);
+
+        address contractAddress = address(mock1155NoOwner);
+        uint256 tokenId = tokenId1;
+
+        IComments.CommentIdentifier memory replyTo;
+
+        vm.prank(collectorWithToken);
+        vm.expectRevert(abi.encodeWithSelector(IComments.NoFundsRecipient.selector));
+        comments.comment{value: sparksQuantity * SPARKS_VALUE}(collectorWithToken, contractAddress, tokenId, "test comment", replyTo, address(0), address(0));
+    }
+
+    function testImplementation() public view {
+        assertEq(comments.implementation(), address(commentsImpl));
+    }
+
+    function testCommentsConstructorAddressZero() public {
+        vm.expectRevert(abi.encodeWithSelector(IComments.AddressZero.selector));
+        new CommentsImpl(SPARKS_VALUE, address(0), zoraRecipient);
+
+        vm.expectRevert(abi.encodeWithSelector(IComments.AddressZero.selector));
+        new CommentsImpl(SPARKS_VALUE, address(protocolRewards), address(0));
+    }
+
+    function testCommentsInitializeAddressZero() public {
+        CommentsImpl implTest = new CommentsImpl(SPARKS_VALUE, address(protocolRewards), zoraRecipient);
+        address[] memory delegateCommenters = new address[](0);
+
+        CommentsImpl commentsProxyTest = CommentsImpl(payable(address(new Comments(address(implTest)))));
+        vm.expectRevert(abi.encodeWithSelector(IComments.AddressZero.selector));
+        commentsProxyTest.initialize({defaultAdmin: address(0), backfiller: commentsBackfiller, delegateCommenters: delegateCommenters});
+
+        vm.expectRevert(abi.encodeWithSelector(IComments.AddressZero.selector));
+        commentsProxyTest.initialize({defaultAdmin: commentsAdmin, backfiller: address(0), delegateCommenters: new address[](0)});
+    }
+
+    function testGrantRoleWithBackfillRole() public {
+        address newBackfiller = makeAddr("newBackfiller");
+        bytes32 BACKFILLER_ROLE = keccak256("BACKFILLER_ROLE");
+        vm.prank(commentsAdmin);
+        comments.grantRole(BACKFILLER_ROLE, newBackfiller);
+        vm.assertEq(comments.hasRole(BACKFILLER_ROLE, newBackfiller), true);
+
+        vm.prank(commentsAdmin);
+        comments.revokeRole(BACKFILLER_ROLE, newBackfiller);
+        vm.assertEq(comments.hasRole(BACKFILLER_ROLE, newBackfiller), false);
+
+        address notAdmin = makeAddr("notAdmin");
+        bytes32 no_role;
+        vm.prank(notAdmin);
+        vm.expectRevert(abi.encodeWithSignature("AccessControlUnauthorizedAccount(address,bytes32)", notAdmin, no_role));
+        comments.grantRole(BACKFILLER_ROLE, newBackfiller);
     }
 }

package/test/CommentsTestBase.sol

@@ -7,11 +7,11 @@ 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;
+    CommentsImpl internal commentsImpl;
     Mock1155 internal mock1155;
 
     uint256 internal constant SPARKS_VALUE = 0.000001 ether;
@@ -22,7 +22,8 @@ contract CommentsTestBase is Test {
     address internal commentsAdmin = makeAddr("commentsAdmin");
     address internal commentsBackfiller = makeAddr("commentsBackfiller");
     address internal zoraRecipient = makeAddr("zoraRecipient");
-    address internal tokenAdmin = makeAddr("tokenCreator");
+    address internal tokenAdmin;
+    uint256 internal tokenAdminPrivateKey;
     address internal collectorWithToken;
     uint256 internal collectorWithTokenPrivateKey;
     address internal collectorWithoutToken = makeAddr("collectorWithoutToken");
@@ -34,32 +35,23 @@ contract CommentsTestBase is Test {
 
     function setUp() public {
         protocolRewards = new ProtocolRewards();
-        CommentsImpl commentsImpl = new CommentsImpl(SPARKS_VALUE, address(protocolRewards));
+        commentsImpl = new CommentsImpl(SPARKS_VALUE, address(protocolRewards), zoraRecipient);
 
         // 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
-        });
+        comments.initialize({defaultAdmin: commentsAdmin, backfiller: commentsBackfiller, delegateCommenters: delegateCommenters});
 
         mock1155 = new Mock1155();
+        (tokenAdmin, tokenAdminPrivateKey) = makeAddrAndKey("tokenAdmin");
 
         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(
@@ -71,16 +63,16 @@ contract CommentsTestBase is Test {
     }
 
     function _mockComment(
-        address commentor,
+        address commenter,
         IComments.CommentIdentifier memory replyTo
     ) internal returns (IComments.CommentIdentifier memory commentIdentifier) {
-        vm.startPrank(commentor);
-        mock1155.mint(commentor, tokenId1, 1, "");
+        vm.startPrank(commenter);
+        mock1155.mint(commenter, tokenId1, 1, "");
         vm.stopPrank();
 
-        vm.deal(commentor, SPARKS_VALUE);
+        vm.deal(commenter, SPARKS_VALUE);
 
-        vm.prank(commentor);
-        commentIdentifier = comments.comment{value: SPARKS_VALUE}(commentor, address(mock1155), tokenId1, "comment", replyTo, address(0));
+        vm.prank(commenter);
+        commentIdentifier = comments.comment{value: SPARKS_VALUE}(commenter, address(mock1155), tokenId1, "comment", replyTo, address(0), address(0));
     }
 }

package/test/Comments_delegateComment.t.sol

@@ -0,0 +1,129 @@
+// 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 {MockDelegateCommenter} from "./mocks/MockDelegateCommenter.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 commenter = makeAddr("commenter");
+    address tokenAdmin = makeAddr("tokenAdmin");
+    address backfiller = makeAddr("backfiller");
+    address referrer = makeAddr("referrer");
+
+    uint256 internal constant ZORA_REWARD_PCT = 10;
+    uint256 internal constant REFERRER_REWARD_PCT = 20;
+    uint256 internal constant BPS_TO_PERCENT_2_DECIMAL_PERCISION = 100;
+
+    uint256 tokenId1 = 1;
+
+    address constant protocolRewards = 0x7777777F279eba3d3Ad8F4E708545291A6fDBA8B;
+    MockDelegateCommenter mockDelegateCommenter;
+
+    function setUp() public {
+        vm.createSelectFork("zora_sepolia", 14562731);
+
+        CommentsImpl commentsImpl = new CommentsImpl(SPARKS_VALUE, protocolRewards, zoraRecipient);
+
+        comments = CommentsImpl(payable(address(new Comments(address(commentsImpl)))));
+
+        mockDelegateCommenter = new MockDelegateCommenter(address(comments));
+
+        address[] memory delegateCommenters = new address[](1);
+        delegateCommenters[0] = address(mockDelegateCommenter);
+        comments.initialize({defaultAdmin: commentsAdmin, backfiller: backfiller, 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 testCanDelegateCommentWithSparks() public {
+        uint256 quantityToMint = 1;
+        uint256 mintFee = 0.000111 ether;
+
+        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);
+
+        vm.deal(commenter, mintFee * quantityToMint + SPARKS_VALUE);
+        vm.expectEmit(true, true, true, true);
+        emit IComments.Commented(
+            expectedCommentId,
+            _expectedCommentIdentifier(commenter, contractAddress, tokenId),
+            expectedReplyToId,
+            emptyReplyTo,
+            1,
+            "test",
+            block.timestamp,
+            referrer
+        );
+        vm.prank(commenter);
+        mockDelegateCommenter.mintAndCommentWithSpark{value: SPARKS_VALUE + mintFee * quantityToMint}({
+            quantity: quantityToMint,
+            collection: address(mock1155),
+            tokenId: tokenId1,
+            comment: "test",
+            referrer: referrer,
+            sparksQuantity: 1
+        });
+
+        // validate that the protocol creator received rewards
+        uint256 zoraReward = (SPARKS_VALUE * (ZORA_REWARD_PCT)) / BPS_TO_PERCENT_2_DECIMAL_PERCISION;
+        uint256 referrerReward = (SPARKS_VALUE * (REFERRER_REWARD_PCT)) / BPS_TO_PERCENT_2_DECIMAL_PERCISION;
+        vm.assertEq(comments.protocolRewards().balanceOf(zoraRecipient), zoraReward);
+        vm.assertEq(comments.protocolRewards().balanceOf(referrer), referrerReward);
+        vm.assertEq(comments.protocolRewards().balanceOf(tokenAdmin), SPARKS_VALUE - zoraReward - referrerReward);
+    }
+
+    function testDelegateCommentRevertsWhenMoreThanOneSpark() public {
+        uint256 quantityToMint = 1;
+        uint256 mintFee = 0.000111 ether;
+
+        uint256 sparksQuantity = 2;
+        vm.deal(commenter, mintFee * quantityToMint + SPARKS_VALUE * sparksQuantity);
+
+        vm.prank(commenter);
+        vm.expectRevert(abi.encodeWithSelector(IComments.IncorrectETHAmountForSparks.selector, SPARKS_VALUE * sparksQuantity, SPARKS_VALUE));
+        mockDelegateCommenter.mintAndCommentWithSpark{value: SPARKS_VALUE * sparksQuantity + mintFee * quantityToMint}({
+            quantity: quantityToMint,
+            collection: address(mock1155),
+            tokenId: tokenId1,
+            comment: "test",
+            referrer: referrer,
+            sparksQuantity: sparksQuantity
+        });
+    }
+
+    function test_delegateComment_revertsWhenNotOwnerOrCreator() public {
+        address notOwner = makeAddr("notOwner");
+        vm.prank(notOwner);
+        vm.expectRevert(IComments.NotTokenHolderOrAdmin.selector);
+        mockDelegateCommenter.forwardComment(address(mock1155), tokenId1, "test");
+    }
+}