@zoralabs/comments-contracts 0.0.1

package/src/CommentsImpl.sol

@@ -0,0 +1,552 @@
+// 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";
+import {IComments} from "./interfaces/IComments.sol";
+import {IProtocolRewards} from "@zoralabs/protocol-rewards/src/interfaces/IProtocolRewards.sol";
+import {UnorderedNoncesUpgradeable} from "@zoralabs/shared-contracts/utils/UnorderedNoncesUpgradeable.sol";
+import {EIP712UpgradeableWithChainId} from "./utils/EIP712UpgradeableWithChainId.sol";
+import {SignatureChecker} from "@openzeppelin/contracts/utils/cryptography/SignatureChecker.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";
+
+    /// @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;
+        // 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
+        }
+    }
+
+    function comments(bytes32 commentId) internal view returns (Comment storage) {
+        return _getCommentsStorage().comments[commentId];
+    }
+
+    function commentSparksQuantity(bytes32 commentId) external view returns (uint64) {
+        return comments(commentId).totalSparks;
+    }
+
+    function nextNonce() external view returns (bytes32) {
+        return bytes32(_getCommentsStorage().nonce);
+    }
+
+    uint256 public immutable sparkValue;
+
+    IProtocolRewards public immutable protocolRewards;
+
+    // the sparks value could also be a comment
+    constructor(uint256 _sparkValue, address _protocolRewards) {
+        _disableInitializers();
+
+        sparkValue = _sparkValue;
+        protocolRewards = IProtocolRewards(_protocolRewards);
+    }
+
+    function initialize(address _zoraRecipient, address defaultAdmin, address backfiller, address[] calldata delegateCommenters) public initializer {
+        __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]);
+        }
+    }
+
+    /// @notice Hashes a comment identifier to generate a unique ID
+    /// @param commentIdentifier The comment identifier to hash
+    /// @return The hashed comment identifier
+    function hashCommentIdentifier(CommentIdentifier memory commentIdentifier) public pure returns (bytes32) {
+        return keccak256(abi.encode(commentIdentifier));
+    }
+
+    /// @notice Hashes a comment identifier and checks if a comment exists with that id
+    /// @param commentIdentifier The comment identifier to check
+    /// @return commentId The hashed comment identifier
+    /// @return exists Whether the comment exists
+    function hashAndCheckCommentExists(CommentIdentifier memory commentIdentifier) public view returns (bytes32 commentId, bool exists) {
+        commentId = hashCommentIdentifier(commentIdentifier);
+        exists = comments(commentId).exists;
+    }
+
+    /// @notice Validates that a comment exists and returns its ID
+    /// @param commentIdentifier The comment identifier to validate
+    /// @return commentId The hashed comment identifier
+    function hashAndValidateCommentExists(CommentIdentifier memory commentIdentifier) public view returns (bytes32 commentId) {
+        bool exists;
+        (commentId, exists) = hashAndCheckCommentExists(commentIdentifier);
+        if (!exists) {
+            revert CommentDoesntExist();
+        }
+    }
+
+    /// @notice Creates a new comment.  Equivalant sparks value in eth must be sent with the transaction.  Must be a holder or creator of the referenced 1155 token.
+    /// If not the owner, must send 1 spark.
+    /// @param contractAddress The address of the contract
+    /// @param tokenId The token ID
+    /// @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)
+    /// @return commentIdentifier The identifier of the created comment, including the nonce
+    function comment(
+        address commenter,
+        address contractAddress,
+        uint256 tokenId,
+        string calldata text,
+        CommentIdentifier calldata replyTo,
+        address referrer
+    ) external payable returns (CommentIdentifier memory commentIdentifier) {
+        uint64 sparksQuantity = 0;
+        if (msg.value != 0) {
+            sparksQuantity = 1;
+        }
+        _validateSparksQuantityMatchesValue(sparksQuantity, msg.value);
+
+        commentIdentifier = _createCommentIdentifier(contractAddress, tokenId, commenter);
+
+        _comment(msg.sender, commentIdentifier, text, sparksQuantity, replyTo, referrer, true);
+    }
+
+    // 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.
+    function delegateComment(
+        address commenter,
+        address contractAddress,
+        uint256 tokenId,
+        string calldata text,
+        CommentIdentifier calldata replyTo
+    ) external onlyRole(DELEGATE_COMMENTOR) returns (CommentIdentifier memory commentIdentifier) {
+        commentIdentifier = _createCommentIdentifier(contractAddress, tokenId, commenter);
+
+        _comment(commentIdentifier.commenter, commentIdentifier, text, 0, replyTo, address(0), false);
+    }
+
+    function _createCommentIdentifier(address contractAddress, uint256 tokenId, address commenter) private returns (CommentIdentifier memory) {
+        CommentsStorage storage $ = _getCommentsStorage();
+        return CommentIdentifier({commenter: commenter, contractAddress: contractAddress, tokenId: tokenId, nonce: bytes32($.nonce++)});
+    }
+
+    function _comment(
+        address commenter,
+        CommentIdentifier memory commentIdentifier,
+        string memory text,
+        uint64 sparksQuantity,
+        CommentIdentifier memory replyTo,
+        address referrer,
+        bool mustSendAtLeastOneSpark
+    ) internal returns (bytes32) {
+        if (commentIdentifier.commenter != commenter) {
+            revert CommenterMismatch(commentIdentifier.commenter, commenter);
+        }
+
+        (bytes32 commentId, bytes32 replyToId) = _validateComment(commentIdentifier, replyTo, text, sparksQuantity, mustSendAtLeastOneSpark);
+
+        _saveCommentAndTransferSparks(commentId, commentIdentifier, text, sparksQuantity, replyToId, replyTo, block.timestamp, referrer);
+
+        return commentId;
+    }
+
+    function _validateIdentifiersMatch(CommentIdentifier memory commentIdentifier, CommentIdentifier memory replyTo) internal pure {
+        if (commentIdentifier.contractAddress != replyTo.contractAddress || commentIdentifier.tokenId != replyTo.tokenId) {
+            revert CommentAddressOrTokenIdsDoNotMatch(commentIdentifier.contractAddress, commentIdentifier.tokenId, replyTo.contractAddress, replyTo.tokenId);
+        }
+    }
+
+    function _validateComment(
+        CommentIdentifier memory commentIdentifier,
+        CommentIdentifier memory replyTo,
+        string memory text,
+        uint64 sparksQuantity,
+        bool mustSendAtLeastOneSpark
+    ) internal view returns (bytes32 commentId, bytes32 replyToId) {
+        // verify that the commenter specified in the identifier is the one expected
+        commentId = hashCommentIdentifier(commentIdentifier);
+
+        if (replyTo.commenter != address(0)) {
+            replyToId = hashAndValidateCommentExists(replyTo);
+            _validateIdentifiersMatch(commentIdentifier, replyTo);
+        }
+
+        if (bytes(text).length == 0) {
+            revert EmptyComment();
+        }
+
+        _validateCommentorAndSparksQuantity(commentIdentifier, sparksQuantity, mustSendAtLeastOneSpark);
+    }
+
+    function _validateCommentorAndSparksQuantity(
+        CommentIdentifier memory commentIdentifier,
+        uint64 sparksQuantity,
+        bool mustSendAtLeastOneSpark
+    ) 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)) {
+            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)) {
+            revert NotTokenHolderOrAdmin();
+        }
+
+        if (mustSendAtLeastOneSpark && sparksQuantity == 0) {
+            revert MustSendAtLeastOneSpark();
+        }
+    }
+
+    bytes4 constant zoraRewardReason = bytes4(keccak256("zoraRewardForCommentDeposited()"));
+    bytes4 constant referrerRewardReason = bytes4(keccak256("referrerRewardForCommentDeposited()"));
+    bytes4 constant sparksRecipientRewardReason = bytes4(keccak256("sparksRecipientRewardForCommentDeposited()"));
+
+    function _getRewardDeposits(
+        address sparksRecipient,
+        address referrer,
+        uint256 sparksValue
+    ) internal view returns (address[] memory, uint256[] memory, bytes4[] memory) {
+        uint256 recipientCount = referrer != address(0) ? 3 : 2;
+        address[] memory recipients = new address[](recipientCount);
+        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;
+
+            uint256 referrerReward = (REFERRER_REWARD_PCT * sparksValue) / BPS_TO_PERCENT_2_DECIMAL_PERCISION;
+            recipients[1] = referrer;
+            amounts[1] = referrerReward;
+            reasons[1] = referrerRewardReason;
+
+            uint256 sparksRecipientReward = sparksValue - zoraReward - referrerReward;
+            recipients[2] = sparksRecipient;
+            amounts[2] = sparksRecipientReward;
+            reasons[2] = sparksRecipientRewardReason;
+        } else {
+            uint256 zoraRewardNoReferrer = (ZORA_REWARD_NO_REFERRER_PCT * sparksValue) / BPS_TO_PERCENT_2_DECIMAL_PERCISION;
+            recipients[0] = zoraRecipient;
+            amounts[0] = zoraRewardNoReferrer;
+            reasons[0] = zoraRewardReason;
+
+            uint256 sparkRecipientReward = sparksValue - zoraRewardNoReferrer;
+            recipients[1] = sparksRecipient;
+            amounts[1] = sparkRecipientReward;
+            reasons[1] = sparksRecipientRewardReason;
+        }
+
+        return (recipients, amounts, reasons);
+    }
+
+    function _transferSparksValueToRecipient(address sparksRecipient, address referrer, uint256 sparksValue, string memory depositBatchComment) internal {
+        (address[] memory recipients, uint256[] memory amounts, bytes4[] memory reasons) = _getRewardDeposits(sparksRecipient, referrer, sparksValue);
+        protocolRewards.depositBatch{value: sparksValue}(recipients, amounts, reasons, depositBatchComment);
+    }
+
+    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);
+    }
+
+    function _isTokenHolder(address contractAddress, uint256 tokenId, address user) internal view returns (bool) {
+        return IERC1155(contractAddress).balanceOf(user, tokenId) > 0;
+    }
+
+    function _getCommentSparksRecipient(CommentIdentifier memory commentIdentifier, CommentIdentifier memory replyTo) internal view returns (address) {
+        // if there is no reply to, then creator reward recipient of the 1155 token gets the sparks
+        // otherwise, the replay to commenter gets the sparks
+        if (replyTo.commenter == address(0)) {
+            return _getCreatorRewardRecipient(commentIdentifier);
+        }
+
+        return replyTo.commenter;
+    }
+
+    // executes the comment.  assumes sparks have already been transferred to recipient, and data has been validated
+    // assume that the commentId and replyToId are valid
+    function _saveCommentAndTransferSparks(
+        bytes32 commentId,
+        CommentIdentifier memory commentIdentifier,
+        string memory text,
+        uint64 sparksQuantity,
+        bytes32 replyToId,
+        CommentIdentifier memory replyToIdentifier,
+        uint256 timestamp,
+        address referrer
+    ) internal {
+        _saveComment(commentId, commentIdentifier, text, sparksQuantity, replyToId, replyToIdentifier, timestamp, referrer);
+        string memory depositBatchComment = "Comment";
+
+        // update reason if replying to a comment
+        if (replyToId != 0) {
+            depositBatchComment = "Comment Reply";
+        }
+
+        if (sparksQuantity > 0) {
+            address sparksRecipient = _getCommentSparksRecipient(commentIdentifier, replyToIdentifier);
+            _transferSparksValueToRecipient(sparksRecipient, referrer, sparksQuantity * sparkValue, depositBatchComment);
+        }
+    }
+
+    function _saveComment(
+        bytes32 commentId,
+        CommentIdentifier memory commentIdentifier,
+        string memory text,
+        uint64 sparksQuantity,
+        bytes32 replyToId,
+        CommentIdentifier memory replyToIdentifier,
+        uint256 timestamp,
+        address referrer
+    ) internal {
+        if (comments(commentId).exists) {
+            revert DuplicateComment(commentId);
+        }
+        comments(commentId).exists = true;
+
+        emit Commented(commentId, commentIdentifier, replyToId, replyToIdentifier, sparksQuantity, text, timestamp, referrer);
+    }
+
+    /// @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.
+    /// @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 {
+        if (sparksQuantity == 0) {
+            revert MustSendAtLeastOneSpark();
+        }
+        _validateSparksQuantityMatchesValue(sparksQuantity, msg.value);
+        _sparkComment(commentIdentifier, msg.sender, sparksQuantity, referrer);
+    }
+
+    function _validateSparksQuantityMatchesValue(uint64 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 {
+        if (sparker == commentIdentifier.commenter) {
+            revert CannotSparkOwnComment();
+        }
+        bytes32 commentId = hashCommentIdentifier(commentIdentifier);
+        if (!comments(commentId).exists) {
+            revert CommentDoesntExist();
+        }
+
+        comments(commentId).totalSparks += uint64(sparksQuantity);
+
+        _transferSparksValueToRecipient(commentIdentifier.commenter, referrer, sparksQuantity * sparkValue, "Sparked Comment");
+
+        emit SparkedComment(commentId, commentIdentifier, sparksQuantity, sparker, block.timestamp);
+    }
+
+    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(
+                abi.encode(
+                    COMMENT_IDENTIFIER_DOMAIN,
+                    commentIdentifier.contractAddress,
+                    commentIdentifier.tokenId,
+                    commentIdentifier.commenter,
+                    commentIdentifier.nonce
+                )
+            );
+    }
+
+    function _hashTypedDataV4WithCustomChain(bytes32 permitDomain, bytes memory permitData, uint256 sourceChainId) internal view returns (bytes32) {
+        return _hashTypedDataV4(keccak256(abi.encode(permitDomain, permitData)), sourceChainId);
+    }
+
+    function hashPermitComment(PermitComment calldata permit) public view returns (bytes32) {
+        return
+            _hashTypedDataV4WithCustomChain(
+                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
+            );
+    }
+
+    function _validatePermit(bytes32 digest, bytes32 nonce, bytes calldata signature, address signer, uint256 deadline) internal {
+        if (block.timestamp > deadline) {
+            revert ERC2612ExpiredSignature(deadline);
+        }
+
+        _useCheckedNonce(signer, uint256(nonce));
+        _validateSignerIsCommenter(digest, signature, signer);
+    }
+
+    function permitComment(PermitComment calldata permit, bytes calldata signature) public payable {
+        if (permit.destinationChainId != block.chainid) {
+            revert IncorrectDestinationChain(permit.destinationChainId);
+        }
+
+        bytes32 digest = hashPermitComment(permit);
+        _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,
+            commentIdentifier,
+            permit.text,
+            permit.sparksQuantity,
+            replyToId,
+            permit.replyTo,
+            block.timestamp,
+            permit.referrer
+        );
+    }
+
+    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)"
+        );
+
+    function hashPermitSparkComment(PermitSparkComment calldata permit) public view returns (bytes32) {
+        return
+            _hashTypedDataV4WithCustomChain(
+                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
+            );
+    }
+
+    function permitSparkComment(PermitSparkComment calldata permit, bytes calldata signature) public payable {
+        if (permit.destinationChainId != block.chainid) {
+            revert IncorrectDestinationChain(permit.destinationChainId);
+        }
+
+        bytes32 digest = hashPermitSparkComment(permit);
+        _validatePermit(digest, permit.nonce, signature, permit.sparker, permit.deadline);
+
+        if (permit.sparksQuantity == 0) {
+            revert MustSendAtLeastOneSpark();
+        }
+
+        _validateSparksQuantityMatchesValue(permit.sparksQuantity, msg.value);
+
+        _sparkComment(permit.comment, permit.sparker, permit.sparksQuantity, permit.referrer);
+    }
+
+    function _validateSignerIsCommenter(bytes32 digest, bytes calldata signature, address signer) internal view {
+        if (!SignatureChecker.isValidSignatureNow(signer, digest, signature)) {
+            revert InvalidSignature();
+        }
+    }
+
+    /// @notice Backfills comments created by other contracts.  Only callable by an account with the backfiller role.
+    /// @param commentIdentifiers Array of comment identifiers
+    /// @param texts Array of comment texts
+    /// @param timestamps Array of comment timestamps
+    /// @param originalTransactionHashes Array of original transaction hashes
+    function backfillBatchAddComment(
+        CommentIdentifier[] calldata commentIdentifiers,
+        string[] calldata texts,
+        uint256[] calldata timestamps,
+        bytes32[] calldata originalTransactionHashes
+    ) public onlyRole(BACKFILLER_ROLE) {
+        if (commentIdentifiers.length != texts.length || texts.length != timestamps.length || timestamps.length != originalTransactionHashes.length) {
+            revert ArrayLengthMismatch();
+        }
+
+        for (uint256 i = 0; i < commentIdentifiers.length; i++) {
+            bytes32 commentId = hashCommentIdentifier(commentIdentifiers[i]);
+
+            if (comments(commentId).exists) {
+                revert DuplicateComment(commentId);
+            }
+            comments(commentId).exists = true;
+
+            // create blank replyTo - assume that these were created without replyTo
+            emit BackfilledComment(commentId, commentIdentifiers[i], texts[i], timestamps[i], originalTransactionHashes[i]);
+        }
+    }
+
+    function _getCreatorRewardRecipient(CommentIdentifier memory commentIdentifier) internal view returns (address) {
+        // TODO: Implement logic to get creator reward recipient
+        return IZoraCreator1155(commentIdentifier.contractAddress).getCreatorRewardRecipient(commentIdentifier.tokenId);
+    }
+
+    function contractName() public pure returns (string memory) {
+        return "Zora Comments";
+    }
+
+    function _authorizeUpgrade(address newImplementation) internal override onlyRole(DEFAULT_ADMIN_ROLE) {
+        // check that new implementation's contract name matches the current contract name
+        if (!_equals(IHasContractName(newImplementation).contractName(), this.contractName())) {
+            revert UpgradeToMismatchedContractName(this.contractName(), IHasContractName(newImplementation).contractName());
+        }
+    }
+
+    function _equals(string memory a, string memory b) internal pure returns (bool) {
+        return (keccak256(bytes(a)) == keccak256(bytes(b)));
+    }
+}

package/src/deployments/CommentsDeployment.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import {CommentsImpl} from "../CommentsImpl.sol";
+
+library CommentsDeployment {
+    address internal constant SPARKS_1155 = 0x7777777F279eba3d3Ad8F4E708545291A6fDBA8B;
+    uint256 internal constant SPARKS_TOKEN_ID = 1;
+    uint256 internal constant SPARK_VALUE = 0.000001 ether;
+
+    function commentsImplCreationCode() internal pure returns (bytes memory) {
+        return abi.encodePacked(type(CommentsImpl).creationCode, abi.encode(SPARKS_1155, SPARKS_TOKEN_ID, SPARK_VALUE));
+    }
+}