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

package/src/CommentsImpl.sol

@@ -1,11 +1,9 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.23;
 
-import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
 import {AccessControlUpgradeable} from "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
 import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
 import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
-import {ERC1155Holder} from "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";
 import {IHasContractName} from "@zoralabs/shared-contracts/interfaces/IContractMetadata.sol";
 import {ContractVersionBase} from "./version/ContractVersionBase.sol";
 import {IZoraCreator1155} from "./interfaces/IZoraCreator1155.sol";
@@ -14,40 +12,46 @@ import {IProtocolRewards} from "@zoralabs/protocol-rewards/src/interfaces/IProto
 import {UnorderedNoncesUpgradeable} from "@zoralabs/shared-contracts/utils/UnorderedNoncesUpgradeable.sol";
 import {EIP712UpgradeableWithChainId} from "./utils/EIP712UpgradeableWithChainId.sol";
 import {SignatureChecker} from "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
+import {ERC1967Utils} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol";
+import {IMultiOwnable} from "./interfaces/IMultiOwnable.sol";
+import {CommentsImplConstants} from "./CommentsImplConstants.sol";
 
 /// @title CommentsImpl
 /// @notice Contract for comments and sparking (liking with value) Zora 1155 posts.
 /// @dev Implements comment creation, sparking, and backfilling functionality. Implementation contract
 /// meant to be used with a UUPS upgradeable proxy contract.
-contract CommentsImpl is IComments, AccessControlUpgradeable, UUPSUpgradeable, ContractVersionBase, EIP712UpgradeableWithChainId, UnorderedNoncesUpgradeable {
-    // this is the zora creator multisig that can upgrade the contract
-    bytes32 public constant BACKFILLER_ROLE = keccak256("BACKFILLER_ROLE");
-    // allows to delegate comment
-    bytes32 public constant DELEGATE_COMMENTOR = keccak256("DELEGATE_COMMENTOR");
-    uint256 public constant PERMISSION_BIT_ADMIN = 2 ** 1;
-    uint256 public constant ZORA_REWARD_PCT = 10;
-    uint256 public constant REFERRER_REWARD_PCT = 20;
-    uint256 public constant ZORA_REWARD_NO_REFERRER_PCT = 30;
-    uint256 internal constant BPS_TO_PERCENT_2_DECIMAL_PERCISION = 100;
-
-    string public constant DOMAIN_NAME = "ZoraComments";
-    string public constant DOMAIN_VERSION = "1";
+/// @author oveddan / IsabellaSmallcombe
+contract CommentsImpl is
+    IComments,
+    AccessControlUpgradeable,
+    UUPSUpgradeable,
+    ContractVersionBase,
+    EIP712UpgradeableWithChainId,
+    UnorderedNoncesUpgradeable,
+    CommentsImplConstants,
+    IHasContractName
+{
+    /// @notice keccak256(abi.encode(uint256(keccak256("comments.storage.CommentsStorage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 private constant COMMENTS_STORAGE_LOCATION = 0x9e5d0d3a4c7e8d5b9e8f9d9d5b9e8f9d9d5b9e8f9d9d5b9e8f9d9d5b9e8f9d00;
+    /// @notice the spark value to comment
+    uint256 public immutable sparkValue;
+    /// @notice the address of the protocol rewards contract
+    IProtocolRewards public immutable protocolRewards;
+    /// @notice account that receives rewards Zora Rewards for from a portion of the sparks value
+    address immutable zoraRecipient;
 
     /// @custom:storage-location erc7201:comments.storage.CommentsStorage
     struct CommentsStorage {
         mapping(bytes32 => Comment) comments;
-        // account that receives rewards Zora Rewards for from a portion of the sparks value
-        address zoraRecipient;
+        // gap that held old zora recipient.
+        address __gap;
         // Global autoincrementing nonce
         uint256 nonce;
     }
 
-    // keccak256(abi.encode(uint256(keccak256("comments.storage.CommentsStorage")) - 1)) & ~bytes32(uint256(0xff))
-    bytes32 private constant CommentsStorageLocation = 0x9e5d0d3a4c7e8d5b9e8f9d9d5b9e8f9d9d5b9e8f9d9d5b9e8f9d9d5b9e8f9d00;
-
     function _getCommentsStorage() private pure returns (CommentsStorage storage $) {
         assembly {
-            $.slot := CommentsStorageLocation
+            $.slot := COMMENTS_STORAGE_LOCATION
         }
     }
 
@@ -55,38 +59,57 @@ contract CommentsImpl is IComments, AccessControlUpgradeable, UUPSUpgradeable, C
         return _getCommentsStorage().comments[commentId];
     }
 
-    function commentSparksQuantity(bytes32 commentId) external view returns (uint64) {
-        return comments(commentId).totalSparks;
+    /// @notice Returns the total number of sparks a given comment has received
+    /// @param commentIdentifier The identifier of the comment
+    /// @return The total number of sparks a comment has received
+    function commentSparksQuantity(CommentIdentifier memory commentIdentifier) external view returns (uint256) {
+        return comments(hashCommentIdentifier(commentIdentifier)).totalSparks;
     }
 
+    /// @notice Returns the next nonce for comment creation
+    /// @return The next nonce
     function nextNonce() external view returns (bytes32) {
         return bytes32(_getCommentsStorage().nonce);
     }
 
-    uint256 public immutable sparkValue;
-
-    IProtocolRewards public immutable protocolRewards;
+    /// @notice Returns the implementation address of the contract
+    /// @return The implementation address
+    function implementation() external view returns (address) {
+        return ERC1967Utils.getImplementation();
+    }
 
-    // the sparks value could also be a comment
-    constructor(uint256 _sparkValue, address _protocolRewards) {
+    /// @notice Contract constructor
+    /// @param _sparkValue The value of a spark
+    /// @param _protocolRewards The address of the protocol rewards contract
+    /// @param _zoraRecipient The address of the zora recipient
+    constructor(uint256 _sparkValue, address _protocolRewards, address _zoraRecipient) {
+        if (_protocolRewards == address(0) || _zoraRecipient == address(0)) {
+            revert AddressZero();
+        }
         _disableInitializers();
 
         sparkValue = _sparkValue;
         protocolRewards = IProtocolRewards(_protocolRewards);
+        zoraRecipient = _zoraRecipient;
     }
 
-    function initialize(address _zoraRecipient, address defaultAdmin, address backfiller, address[] calldata delegateCommenters) public initializer {
+    /// @notice Initializes the contract with default admin, backfiller, and delegate commenters
+    /// @param defaultAdmin The address of the default admin
+    /// @param backfiller The address of the backfiller
+    /// @param delegateCommenters The addresses of the delegate commenters
+    function initialize(address defaultAdmin, address backfiller, address[] calldata delegateCommenters) public initializer {
+        if (defaultAdmin == address(0) || backfiller == address(0)) {
+            revert AddressZero();
+        }
         __AccessControl_init();
         __UUPSUpgradeable_init();
         __EIP712_init(DOMAIN_NAME, DOMAIN_VERSION);
 
-        _getCommentsStorage().zoraRecipient = _zoraRecipient;
-
         _grantRole(DEFAULT_ADMIN_ROLE, defaultAdmin);
         _grantRole(BACKFILLER_ROLE, backfiller);
 
         for (uint256 i = 0; i < delegateCommenters.length; i++) {
-            _grantRole(DELEGATE_COMMENTOR, delegateCommenters[i]);
+            _grantRole(DELEGATE_COMMENTER, delegateCommenters[i]);
         }
     }
 
@@ -124,6 +147,8 @@ contract CommentsImpl is IComments, AccessControlUpgradeable, UUPSUpgradeable, C
     /// @param commenter The address of the commenter
     /// @param text The text content of the comment
     /// @param replyTo The identifier of the comment being replied to (if any)
+    /// @param commenterSmartWallet If the commenter has a smart wallet, the smart wallet, which can checked to be the owner or creator of the 1155 token
+    /// @param referrer The address of the referrer (if any)
     /// @return commentIdentifier The identifier of the created comment, including the nonce
     function comment(
         address commenter,
@@ -131,31 +156,71 @@ contract CommentsImpl is IComments, AccessControlUpgradeable, UUPSUpgradeable, C
         uint256 tokenId,
         string calldata text,
         CommentIdentifier calldata replyTo,
+        address commenterSmartWallet,
         address referrer
     ) external payable returns (CommentIdentifier memory commentIdentifier) {
-        uint64 sparksQuantity = 0;
-        if (msg.value != 0) {
-            sparksQuantity = 1;
-        }
-        _validateSparksQuantityMatchesValue(sparksQuantity, msg.value);
+        uint256 sparksQuantity = _getAndValidateSingleSparkQuantityFromValue(msg.value);
 
         commentIdentifier = _createCommentIdentifier(contractAddress, tokenId, commenter);
 
-        _comment(msg.sender, commentIdentifier, text, sparksQuantity, replyTo, referrer, true);
+        _comment({
+            commenter: msg.sender,
+            commentIdentifier: commentIdentifier,
+            text: text,
+            sparksQuantity: sparksQuantity,
+            replyTo: replyTo,
+            commenterSmartWallet: commenterSmartWallet,
+            referrer: referrer,
+            mustSendAtLeastOneSpark: true
+        });
+    }
+
+    // gets the sparks quantity from the value sent with the transaction,
+    // ensuring that at most 1 spark is sent.
+    function _getAndValidateSingleSparkQuantityFromValue(uint256 value) internal view returns (uint256) {
+        if (value == 0) {
+            return 0;
+        }
+        if (value != sparkValue) {
+            revert IncorrectETHAmountForSparks(value, sparkValue);
+        }
+        return 1;
     }
 
-    // allows another contract to call this function to signify a caller commented, and is trusted
-    // to provide who the original commentor was. also allows no sparks to be sent.
+    // Allows another contract to call this function to signify a caller commented, and is trusted
+    // to provide who the original commenter was. Allows no sparks to be sent.
+    /// @notice Allows another contract to delegate comment creation on behalf of a user
+    /// @param commenter The address of the commenter
+    /// @param contractAddress The address of the contract
+    /// @param tokenId The token ID
+    /// @param text The text content of the comment
+    /// @param replyTo The identifier of the comment being replied to (if any)
+    /// @param referrer The address of the referrer (if any)
+    /// @param commenterSmartWalletOwner If the commenter has a smart wallet, the smart wallet owner address
+    /// @return commentIdentifier The identifier of the created comment, including the nonce
     function delegateComment(
         address commenter,
         address contractAddress,
         uint256 tokenId,
         string calldata text,
-        CommentIdentifier calldata replyTo
-    ) external onlyRole(DELEGATE_COMMENTOR) returns (CommentIdentifier memory commentIdentifier) {
+        CommentIdentifier calldata replyTo,
+        address commenterSmartWalletOwner,
+        address referrer
+    ) external payable onlyRole(DELEGATE_COMMENTER) returns (CommentIdentifier memory commentIdentifier, bytes32 commentId) {
+        uint256 sparksQuantity = _getAndValidateSingleSparkQuantityFromValue(msg.value);
+
         commentIdentifier = _createCommentIdentifier(contractAddress, tokenId, commenter);
 
-        _comment(commentIdentifier.commenter, commentIdentifier, text, 0, replyTo, address(0), false);
+        commentId = _comment({
+            commenter: commentIdentifier.commenter,
+            commentIdentifier: commentIdentifier,
+            text: text,
+            sparksQuantity: sparksQuantity,
+            replyTo: replyTo,
+            commenterSmartWallet: commenterSmartWalletOwner,
+            referrer: referrer,
+            mustSendAtLeastOneSpark: false
+        });
     }
 
     function _createCommentIdentifier(address contractAddress, uint256 tokenId, address commenter) private returns (CommentIdentifier memory) {
@@ -167,8 +232,9 @@ contract CommentsImpl is IComments, AccessControlUpgradeable, UUPSUpgradeable, C
         address commenter,
         CommentIdentifier memory commentIdentifier,
         string memory text,
-        uint64 sparksQuantity,
+        uint256 sparksQuantity,
         CommentIdentifier memory replyTo,
+        address commenterSmartWallet,
         address referrer,
         bool mustSendAtLeastOneSpark
     ) internal returns (bytes32) {
@@ -176,7 +242,14 @@ contract CommentsImpl is IComments, AccessControlUpgradeable, UUPSUpgradeable, C
             revert CommenterMismatch(commentIdentifier.commenter, commenter);
         }
 
-        (bytes32 commentId, bytes32 replyToId) = _validateComment(commentIdentifier, replyTo, text, sparksQuantity, mustSendAtLeastOneSpark);
+        (bytes32 commentId, bytes32 replyToId) = _validateComment(
+            commentIdentifier,
+            replyTo,
+            text,
+            sparksQuantity,
+            commenterSmartWallet,
+            mustSendAtLeastOneSpark
+        );
 
         _saveCommentAndTransferSparks(commentId, commentIdentifier, text, sparksQuantity, replyToId, replyTo, block.timestamp, referrer);
 
@@ -193,7 +266,8 @@ contract CommentsImpl is IComments, AccessControlUpgradeable, UUPSUpgradeable, C
         CommentIdentifier memory commentIdentifier,
         CommentIdentifier memory replyTo,
         string memory text,
-        uint64 sparksQuantity,
+        uint256 sparksQuantity,
+        address commenterSmartWallet,
         bool mustSendAtLeastOneSpark
     ) internal view returns (bytes32 commentId, bytes32 replyToId) {
         // verify that the commenter specified in the identifier is the one expected
@@ -208,20 +282,35 @@ contract CommentsImpl is IComments, AccessControlUpgradeable, UUPSUpgradeable, C
             revert EmptyComment();
         }
 
-        _validateCommentorAndSparksQuantity(commentIdentifier, sparksQuantity, mustSendAtLeastOneSpark);
+        _validateCommenterAndSparksQuantity(commentIdentifier, sparksQuantity, mustSendAtLeastOneSpark, commenterSmartWallet);
     }
 
-    function _validateCommentorAndSparksQuantity(
+    function _validateCommenterAndSparksQuantity(
         CommentIdentifier memory commentIdentifier,
-        uint64 sparksQuantity,
-        bool mustSendAtLeastOneSpark
+        uint256 sparksQuantity,
+        bool mustSendAtLeastOneSpark,
+        address commenterSmartWallet
     ) internal view {
-        // check that the commenter is a token admin - if they are, then they can comment for free
-        if (_isTokenAdmin(commentIdentifier.contractAddress, commentIdentifier.tokenId, commentIdentifier.commenter)) {
+        if (commenterSmartWallet != address(0)) {
+            if (commenterSmartWallet.code.length == 0) {
+                revert NotSmartWallet();
+            }
+            // check if the commenter is a smart wallet owner
+            if (!IMultiOwnable(commenterSmartWallet).isOwnerAddress(commentIdentifier.commenter)) {
+                revert NotSmartWalletOwner();
+            }
+        }
+
+        // check that the commenter or smart wallet is a token admin - if they are, then they can comment for free
+        if (
+            _accountOrSmartWalletIsTokenAdmin(commentIdentifier.contractAddress, commentIdentifier.tokenId, commentIdentifier.commenter, commenterSmartWallet)
+        ) {
             return;
         }
-        // if they aren't, then they must be a token holder, and have included at least 1 spark
-        if (!_isTokenHolder(commentIdentifier.contractAddress, commentIdentifier.tokenId, commentIdentifier.commenter)) {
+        // if they aren't, commenter or smart wallet must be a token holder, and have included at least 1 spark
+        if (
+            !_accountOrSmartWalletIsTokenHolder(commentIdentifier.contractAddress, commentIdentifier.tokenId, commentIdentifier.commenter, commenterSmartWallet)
+        ) {
             revert NotTokenHolderOrAdmin();
         }
 
@@ -230,10 +319,6 @@ contract CommentsImpl is IComments, AccessControlUpgradeable, UUPSUpgradeable, C
         }
     }
 
-    bytes4 constant zoraRewardReason = bytes4(keccak256("zoraRewardForCommentDeposited()"));
-    bytes4 constant referrerRewardReason = bytes4(keccak256("referrerRewardForCommentDeposited()"));
-    bytes4 constant sparksRecipientRewardReason = bytes4(keccak256("sparksRecipientRewardForCommentDeposited()"));
-
     function _getRewardDeposits(
         address sparksRecipient,
         address referrer,
@@ -244,33 +329,31 @@ contract CommentsImpl is IComments, AccessControlUpgradeable, UUPSUpgradeable, C
         uint256[] memory amounts = new uint256[](recipientCount);
         bytes4[] memory reasons = new bytes4[](recipientCount);
 
-        address zoraRecipient = _getCommentsStorage().zoraRecipient;
-
         if (referrer != address(0)) {
             uint256 zoraReward = (ZORA_REWARD_PCT * sparksValue) / BPS_TO_PERCENT_2_DECIMAL_PERCISION;
             recipients[0] = zoraRecipient;
             amounts[0] = zoraReward;
-            reasons[0] = zoraRewardReason;
+            reasons[0] = ZORA_REWARD_REASON;
 
             uint256 referrerReward = (REFERRER_REWARD_PCT * sparksValue) / BPS_TO_PERCENT_2_DECIMAL_PERCISION;
             recipients[1] = referrer;
             amounts[1] = referrerReward;
-            reasons[1] = referrerRewardReason;
+            reasons[1] = REFERRER_REWARD_REASON;
 
             uint256 sparksRecipientReward = sparksValue - zoraReward - referrerReward;
             recipients[2] = sparksRecipient;
             amounts[2] = sparksRecipientReward;
-            reasons[2] = sparksRecipientRewardReason;
+            reasons[2] = SPARKS_RECIPIENT_REWARD_REASON;
         } else {
             uint256 zoraRewardNoReferrer = (ZORA_REWARD_NO_REFERRER_PCT * sparksValue) / BPS_TO_PERCENT_2_DECIMAL_PERCISION;
             recipients[0] = zoraRecipient;
             amounts[0] = zoraRewardNoReferrer;
-            reasons[0] = zoraRewardReason;
+            reasons[0] = ZORA_REWARD_REASON;
 
             uint256 sparkRecipientReward = sparksValue - zoraRewardNoReferrer;
             recipients[1] = sparksRecipient;
             amounts[1] = sparkRecipientReward;
-            reasons[1] = sparksRecipientRewardReason;
+            reasons[1] = SPARKS_RECIPIENT_REWARD_REASON;
         }
 
         return (recipients, amounts, reasons);
@@ -281,8 +364,27 @@ contract CommentsImpl is IComments, AccessControlUpgradeable, UUPSUpgradeable, C
         protocolRewards.depositBatch{value: sparksValue}(recipients, amounts, reasons, depositBatchComment);
     }
 
+    function _accountOrSmartWalletIsTokenAdmin(address contractAddress, uint256 tokenId, address user, address smartWallet) internal view returns (bool) {
+        if (_isTokenAdmin(contractAddress, tokenId, user)) {
+            return true;
+        }
+        if (smartWallet != address(0)) {
+            return _isTokenAdmin(contractAddress, tokenId, smartWallet);
+        }
+        return false;
+    }
+
+    function _accountOrSmartWalletIsTokenHolder(address contractAddress, uint256 tokenId, address user, address smartWallet) internal view returns (bool) {
+        if (_isTokenHolder(contractAddress, tokenId, user)) {
+            return true;
+        }
+        if (smartWallet != address(0)) {
+            return _isTokenHolder(contractAddress, tokenId, smartWallet);
+        }
+        return false;
+    }
+
     function _isTokenAdmin(address contractAddress, uint256 tokenId, address user) internal view returns (bool) {
-        // TOOD: investigate is there a better way to know the token creator?
         return IZoraCreator1155(contractAddress).isAdminOrRole(user, tokenId, PERMISSION_BIT_ADMIN);
     }
 
@@ -306,7 +408,7 @@ contract CommentsImpl is IComments, AccessControlUpgradeable, UUPSUpgradeable, C
         bytes32 commentId,
         CommentIdentifier memory commentIdentifier,
         string memory text,
-        uint64 sparksQuantity,
+        uint256 sparksQuantity,
         bytes32 replyToId,
         CommentIdentifier memory replyToIdentifier,
         uint256 timestamp,
@@ -330,7 +432,7 @@ contract CommentsImpl is IComments, AccessControlUpgradeable, UUPSUpgradeable, C
         bytes32 commentId,
         CommentIdentifier memory commentIdentifier,
         string memory text,
-        uint64 sparksQuantity,
+        uint256 sparksQuantity,
         bytes32 replyToId,
         CommentIdentifier memory replyToIdentifier,
         uint256 timestamp,
@@ -345,11 +447,11 @@ contract CommentsImpl is IComments, AccessControlUpgradeable, UUPSUpgradeable, C
     }
 
     /// @notice Sparks a comment.  Equivalant sparks value in eth to sparksQuantity must be sent with the transaction.  Sparking a comment is
-    /// similar to liking it, except it is liked with the value of sparks attached.  The spark value gets sent to the commentor, with a fee taken out.
+    /// similar to liking it, except it is liked with the value of sparks attached.  The spark value gets sent to the commenter, with a fee taken out.
     /// @param commentIdentifier The identifier of the comment to spark
     /// @param sparksQuantity The quantity of sparks to send
     /// @param referrer The referrer of the comment
-    function sparkComment(CommentIdentifier calldata commentIdentifier, uint64 sparksQuantity, address referrer) public payable {
+    function sparkComment(CommentIdentifier calldata commentIdentifier, uint256 sparksQuantity, address referrer) public payable {
         if (sparksQuantity == 0) {
             revert MustSendAtLeastOneSpark();
         }
@@ -357,13 +459,13 @@ contract CommentsImpl is IComments, AccessControlUpgradeable, UUPSUpgradeable, C
         _sparkComment(commentIdentifier, msg.sender, sparksQuantity, referrer);
     }
 
-    function _validateSparksQuantityMatchesValue(uint64 sparksQuantity, uint256 value) internal view {
+    function _validateSparksQuantityMatchesValue(uint256 sparksQuantity, uint256 value) internal view {
         if (value != sparksQuantity * sparkValue) {
             revert IncorrectETHAmountForSparks(value, sparksQuantity * sparkValue);
         }
     }
 
-    function _sparkComment(CommentIdentifier memory commentIdentifier, address sparker, uint64 sparksQuantity, address referrer) internal {
+    function _sparkComment(CommentIdentifier memory commentIdentifier, address sparker, uint256 sparksQuantity, address referrer) internal {
         if (sparker == commentIdentifier.commenter) {
             revert CannotSparkOwnComment();
         }
@@ -372,20 +474,13 @@ contract CommentsImpl is IComments, AccessControlUpgradeable, UUPSUpgradeable, C
             revert CommentDoesntExist();
         }
 
-        comments(commentId).totalSparks += uint64(sparksQuantity);
+        comments(commentId).totalSparks += uint256(sparksQuantity);
 
         _transferSparksValueToRecipient(commentIdentifier.commenter, referrer, sparksQuantity * sparkValue, "Sparked Comment");
 
-        emit SparkedComment(commentId, commentIdentifier, sparksQuantity, sparker, block.timestamp);
+        emit SparkedComment(commentId, commentIdentifier, sparksQuantity, sparker, block.timestamp, referrer);
     }
 
-    bytes32 constant PERMIT_COMMENT_DOMAIN =
-        keccak256(
-            "PermitComment(address contractAddress,uint256 tokenId,address commenter,CommentIdentifier replyTo,bytes text,uint64 sparksQuantity,uint256 deadline,bytes32 nonce,address referrer,uint256 sourceChainId,uint256 destinationChainId)CommentIdentifier(address contractAddress,uint256 tokenId,address commenter,bytes32 nonce)"
-        );
-
-    bytes32 constant COMMENT_IDENTIFIER_DOMAIN = keccak256("CommentIdentifier(address contractAddress,uint256 tokenId,address commenter,bytes32 nonce)");
-
     function _hashCommentIdentifier(CommentIdentifier memory commentIdentifier) internal pure returns (bytes32) {
         return
             keccak256(
@@ -399,29 +494,28 @@ contract CommentsImpl is IComments, AccessControlUpgradeable, UUPSUpgradeable, C
             );
     }
 
-    function _hashTypedDataV4WithCustomChain(bytes32 permitDomain, bytes memory permitData, uint256 sourceChainId) internal view returns (bytes32) {
-        return _hashTypedDataV4(keccak256(abi.encode(permitDomain, permitData)), sourceChainId);
-    }
-
+    /// @notice Hashes a permit comment struct for signing
+    /// @param permit The permit comment struct
+    /// @return The hash to sign
     function hashPermitComment(PermitComment calldata permit) public view returns (bytes32) {
-        return
-            _hashTypedDataV4WithCustomChain(
+        bytes32 structHash = keccak256(
+            abi.encode(
                 PERMIT_COMMENT_DOMAIN,
-                abi.encode(
-                    permit.contractAddress,
-                    permit.tokenId,
-                    permit.commenter,
-                    _hashCommentIdentifier(permit.replyTo),
-                    keccak256(bytes(permit.text)),
-                    permit.sparksQuantity,
-                    permit.deadline,
-                    permit.nonce,
-                    permit.referrer,
-                    permit.sourceChainId,
-                    permit.destinationChainId
-                ),
-                permit.sourceChainId
-            );
+                permit.contractAddress,
+                permit.tokenId,
+                permit.commenter,
+                _hashCommentIdentifier(permit.replyTo),
+                keccak256(bytes(permit.text)),
+                permit.deadline,
+                permit.nonce,
+                permit.commenterSmartWallet,
+                permit.referrer,
+                permit.sourceChainId,
+                permit.destinationChainId
+            )
+        );
+
+        return _hashTypedDataV4(structHash, permit.sourceChainId);
     }
 
     function _validatePermit(bytes32 digest, bytes32 nonce, bytes calldata signature, address signer, uint256 deadline) internal {
@@ -429,12 +523,16 @@ contract CommentsImpl is IComments, AccessControlUpgradeable, UUPSUpgradeable, C
             revert ERC2612ExpiredSignature(deadline);
         }
 
-        _useCheckedNonce(signer, uint256(nonce));
+        _useCheckedNonce(signer, nonce);
         _validateSignerIsCommenter(digest, signature, signer);
     }
 
+    /// @notice Creates a comment on behalf of another account using a signed message.  Supports cross-chain permits
+    /// by specifying the source and destination chain ids.  The signature must be signed by the commenter on the source chain.
+    /// @param permit The permit that was signed off-chain on the source chain
+    /// @param signature The signature of the permit comment
     function permitComment(PermitComment calldata permit, bytes calldata signature) public payable {
-        if (permit.destinationChainId != block.chainid) {
+        if (permit.destinationChainId != uint32(block.chainid)) {
             revert IncorrectDestinationChain(permit.destinationChainId);
         }
 
@@ -442,45 +540,46 @@ contract CommentsImpl is IComments, AccessControlUpgradeable, UUPSUpgradeable, C
         _validatePermit(digest, permit.nonce, signature, permit.commenter, permit.deadline);
 
         CommentIdentifier memory commentIdentifier = _createCommentIdentifier(permit.contractAddress, permit.tokenId, permit.commenter);
-        (bytes32 commentId, bytes32 replyToId) = _validateComment(commentIdentifier, permit.replyTo, permit.text, permit.sparksQuantity, true);
 
-        _saveCommentAndTransferSparks(
-            commentId,
+        uint256 sparksQuantity = _getAndValidateSingleSparkQuantityFromValue(msg.value);
+
+        (bytes32 commentId, bytes32 replyToId) = _validateComment(
             commentIdentifier,
-            permit.text,
-            permit.sparksQuantity,
-            replyToId,
             permit.replyTo,
-            block.timestamp,
-            permit.referrer
+            permit.text,
+            sparksQuantity,
+            permit.commenterSmartWallet,
+            true
         );
-    }
 
-    bytes32 constant PERMIT_SPARK_COMMENT_DOMAIN =
-        keccak256(
-            "PermitSparkComment(CommentIdentifier comment,address sparker,uint64 sparksQuantity,uint256 deadline,bytes32 nonce,address referrer,uint256 sourceChainId,uint256 destinationChainId)CommentIdentifier(address contractAddress,uint256 tokenId,address commenter,bytes32 nonce)"
-        );
+        _saveCommentAndTransferSparks(commentId, commentIdentifier, permit.text, sparksQuantity, replyToId, permit.replyTo, block.timestamp, permit.referrer);
+    }
 
+    /// @notice Hashes a permit spark comment struct for signing
+    /// @param permit The permit spark comment struct
     function hashPermitSparkComment(PermitSparkComment calldata permit) public view returns (bytes32) {
-        return
-            _hashTypedDataV4WithCustomChain(
+        bytes32 structHash = keccak256(
+            abi.encode(
                 PERMIT_SPARK_COMMENT_DOMAIN,
-                abi.encode(
-                    _hashCommentIdentifier(permit.comment),
-                    permit.sparker,
-                    permit.sparksQuantity,
-                    permit.deadline,
-                    permit.nonce,
-                    permit.referrer,
-                    permit.sourceChainId,
-                    permit.destinationChainId
-                ),
-                permit.sourceChainId
-            );
+                _hashCommentIdentifier(permit.comment),
+                permit.sparker,
+                permit.sparksQuantity,
+                permit.deadline,
+                permit.nonce,
+                permit.referrer,
+                permit.sourceChainId,
+                permit.destinationChainId
+            )
+        );
+        return _hashTypedDataV4(structHash, permit.sourceChainId);
     }
 
+    /// @notice Sparks a comment on behalf of another account using a signed message.  Supports cross-chain permits
+    /// by specifying the source and destination chain ids.  The signature must be signed by the sparker on the source chain.
+    /// @param permit The permit spark comment struct
+    /// @param signature The signature of the permit. Must be signed by the sparker.
     function permitSparkComment(PermitSparkComment calldata permit, bytes calldata signature) public payable {
-        if (permit.destinationChainId != block.chainid) {
+        if (permit.destinationChainId != uint32(block.chainid)) {
             revert IncorrectDestinationChain(permit.destinationChainId);
         }
 
@@ -530,11 +629,45 @@ contract CommentsImpl is IComments, AccessControlUpgradeable, UUPSUpgradeable, C
         }
     }
 
+    function _getFundsRecipient(address contractAddress) internal view returns (address) {
+        try IZoraCreator1155(contractAddress).config() returns (address, uint96, address payable fundsRecipient, uint96, address, uint96) {
+            if (fundsRecipient != address(0)) {
+                return fundsRecipient;
+            }
+        } catch {}
+
+        try IZoraCreator1155(contractAddress).owner() returns (address owner) {
+            if (owner != address(0)) {
+                return owner;
+            }
+        } catch {}
+
+        return address(0);
+    }
+
+    function _tryGetCreatorRewardRecipient(CommentIdentifier memory commentIdentifier) internal view returns (address) {
+        try IZoraCreator1155(commentIdentifier.contractAddress).getCreatorRewardRecipient(commentIdentifier.tokenId) returns (address creatorRecipient) {
+            return creatorRecipient;
+        } catch {
+            return address(0);
+        }
+    }
+
     function _getCreatorRewardRecipient(CommentIdentifier memory commentIdentifier) internal view returns (address) {
-        // TODO: Implement logic to get creator reward recipient
-        return IZoraCreator1155(commentIdentifier.contractAddress).getCreatorRewardRecipient(commentIdentifier.tokenId);
+        address creatorRecipient = _tryGetCreatorRewardRecipient(commentIdentifier);
+        if (creatorRecipient != address(0)) {
+            return creatorRecipient;
+        }
+
+        address fundsRecipient = _getFundsRecipient(commentIdentifier.contractAddress);
+        if (fundsRecipient != address(0)) {
+            return fundsRecipient;
+        }
+        revert NoFundsRecipient();
     }
 
+    /// @notice Returns the name of the contract
+    /// @return The name of the contract
     function contractName() public pure returns (string memory) {
         return "Zora Comments";
     }