@zoralabs/comments-contracts 0.0.1

package/src/interfaces/IComments.sol

@@ -0,0 +1,156 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+interface IComments {
+    struct CommentIdentifier {
+        address commenter;
+        address contractAddress;
+        uint256 tokenId;
+        bytes32 nonce;
+    }
+
+    struct Comment {
+        // has this comment been created
+        bool exists;
+        // total sparks for this comment
+        uint64 totalSparks;
+    }
+
+    // Event emitted when a comment is created
+    event Commented(
+        bytes32 indexed commentId, // Unique identifier for the comment
+        CommentIdentifier comment, // Struct containing details about the comment and commenter
+        bytes32 replyToId, // ID of the comment being replied to (if any)
+        CommentIdentifier replyTo, // Struct containing details about the comment being replied to (if any)
+        uint64 sparksQuantity, // Number of sparks associated with this comment
+        string text, // The actual text content of the comment
+        uint256 timestamp, // Timestamp when the comment was created
+        address referrer // Address of the referrer who referred the commenter
+    );
+
+    // Event emitted when a comment is backfilled
+    event BackfilledComment(
+        bytes32 indexed commentId, // Unique identifier for the backfilled comment
+        CommentIdentifier comment, // Struct containing details about the comment and commenter
+        string text, // The actual text content of the backfilled comment
+        uint256 timestamp, // Timestamp when the original comment was created
+        bytes32 originalTransactionId // Transaction ID of the original comment (before backfilling)
+    );
+
+    // Event emitted when a comment is Sparked
+    event SparkedComment(
+        bytes32 indexed commentId, // Unique identifier of the comment being sparked
+        CommentIdentifier commentIdentifier, // Struct containing details about the comment and commenter
+        uint64 sparksQuantity, // Number of sparks added to the comment
+        address sparker, // Address of the user who sparked the comment
+        uint256 timestamp // Timestamp when the spark action occurred
+    );
+
+    /// @notice Occurs when attempting to add a comment that already exists
+    /// @param commentId The unique identifier of the duplicate comment
+    error DuplicateComment(bytes32 commentId);
+
+    /// @notice Occurs when the amount of ETH sent with the transaction doesn't match the corresponding sparks quantity
+    error IncorrectETHAmountForSparks(uint256 actual, uint256 expected);
+
+    /// @notice Occurs when the commenter address doesn't match the expected address
+    /// @param expected The address that was expected to be the commenter
+    /// @param actual The actual address that attempted to comment
+    error CommenterMismatch(address expected, address actual);
+
+    /// @notice Occurs when a non-token holder or non-admin attempts an action restricted to token holders or admins
+    error NotTokenHolderOrAdmin();
+
+    /// @notice Occurs when attempting to spark a comment without sending at least one spark
+    error MustSendAtLeastOneSpark();
+
+    /// @notice Occurs when attempting to submit an empty comment
+    error EmptyComment();
+
+    /// @notice Occurs when trying to interact with a comment that doesn't exist
+    error CommentDoesntExist();
+
+    /// @notice Occurs when a transfer of funds fails
+    error TransferFailed();
+
+    /// @notice Occurs when a user attempts to spark their own comment
+    error CannotSparkOwnComment();
+
+    /// @notice Occurs when a function restricted to the Sparks contract is called by another address
+    error OnlySparksContract();
+
+    /// @notice Occurs when attempting to upgrade to a contract with a name that doesn't match the current contract's name
+    /// @param currentName The name of the current contract
+    /// @param newName The name of the contract being upgraded to
+    error UpgradeToMismatchedContractName(string currentName, string newName);
+
+    /// @notice Occurs when the lengths of arrays passed to a function do not match
+    error ArrayLengthMismatch();
+
+    /// @notice Occurs when the address or token IDs in a comment identifier do not match the expected values
+    /// @param commentAddress The address in the comment identifier
+    /// @param commentTokenId The token ID in the comment identifier
+    /// @param replyAddress The address in the reply identifier
+    /// @param replyTokenId The token ID in the reply identifier
+    error CommentAddressOrTokenIdsDoNotMatch(address commentAddress, uint256 commentTokenId, address replyAddress, uint256 replyTokenId);
+    /// @notice Occurs when the signature is invalid
+    error InvalidSignature();
+
+    /// @notice Occurs when the destination chain ID doesn't match the current chain ID in a permit
+    error IncorrectDestinationChain(uint256 wrongDestinationChainId);
+
+    /**
+     * @dev Permit deadline has expired.
+     */
+    error ERC2612ExpiredSignature(uint256 deadline);
+
+    function comment(
+        address commenter,
+        address contractAddress,
+        uint256 tokenId,
+        string calldata text,
+        CommentIdentifier calldata replyTo,
+        address referrer
+    ) external payable returns (CommentIdentifier memory);
+
+    function delegateComment(
+        address commenter,
+        address contractAddress,
+        uint256 tokenId,
+        string calldata text,
+        CommentIdentifier calldata replyTo
+    ) external returns (CommentIdentifier memory);
+
+    function sparkComment(CommentIdentifier calldata commentIdentifier, uint64 sparksQuantity, address referrer) external payable;
+
+    function sparkValue() external view returns (uint256);
+
+    function hashCommentIdentifier(CommentIdentifier calldata commentIdentifier) external view returns (bytes32);
+
+    function nextNonce() external view returns (bytes32);
+
+    struct PermitComment {
+        address commenter;
+        address contractAddress;
+        uint256 tokenId;
+        CommentIdentifier replyTo;
+        string text;
+        uint64 sparksQuantity;
+        uint256 deadline;
+        bytes32 nonce;
+        address referrer;
+        uint256 sourceChainId;
+        uint256 destinationChainId;
+    }
+
+    struct PermitSparkComment {
+        CommentIdentifier comment;
+        address sparker;
+        uint64 sparksQuantity;
+        uint256 deadline;
+        bytes32 nonce;
+        address referrer;
+        uint256 sourceChainId;
+        uint256 destinationChainId;
+    }
+}

package/src/interfaces/IZoraCreator1155.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {IERC1155} from "@openzeppelin/contracts/interfaces/IERC1155.sol";
+
+interface IZoraCreator1155 is IERC1155 {
+    function isAdminOrRole(address user, uint256 tokenId, uint256 role) external view returns (bool);
+
+    function getCreatorRewardRecipient(uint256 tokenId) external view returns (address);
+
+    function supportsInterface(bytes4 interfaceId) external view returns (bool);
+}

package/src/proxy/Comments.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {Enjoy} from "_imagine/Enjoy.sol";
+import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
+
+/*
+
+
+             ░░░░░░░░░░░░░░              
+        ░░▒▒░░░░░░░░░░░░░░░░░░░░        
+      ░░▒▒▒▒░░░░░░░░░░░░░░░░░░░░░░      
+    ░░▒▒▒▒░░░░░░░░░░░░░░    ░░░░░░░░    
+   ░▓▓▒▒▒▒░░░░░░░░░░░░        ░░░░░░░    
+  ░▓▓▓▒▒▒▒░░░░░░░░░░░░        ░░░░░░░░  
+  ░▓▓▓▒▒▒▒░░░░░░░░░░░░░░    ░░░░░░░░░░  
+  ░▓▓▓▒▒▒▒▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░░  
+  ░▓▓▓▓▓▒▒▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░  
+   ░▓▓▓▓▒▒▒▒▒▒░░░░░░░░░░░░░░░░░░░░░░░  
+    ░░▓▓▓▓▒▒▒▒▒▒░░░░░░░░░░░░░░░░░░░░    
+    ░░▓▓▓▓▓▓▒▒▒▒▒▒▒▒░░░░░░░░░▒▒▒▒▒░░    
+      ░░▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░░      
+          ░░▓▓▓▓▓▓▓▓▓▓▓▓▒▒░░░          
+
+               OURS TRULY,
+
+
+ */
+
+/// @title Zora Comments Proxy Contract
+/// @notice This is the proxy contract for the Zora Comments contract.
+/// @dev Inherits from ERC1967Proxy to enable upgradeable functionality.
+/// @notice Imagine. Mint. Enjoy.
+/// @author @oveddan
+contract Comments is Enjoy, ERC1967Proxy {
+    bytes32 internal immutable name;
+
+    constructor(address _logic) ERC1967Proxy(_logic, "") {
+        // added to create unique bytecode for this contract
+        // so that it can be properly verified as its own contract.
+        name = keccak256("Comments");
+    }
+}

package/src/utils/EIP712UpgradeableWithChainId.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+
+abstract contract EIP712UpgradeableWithChainId is Initializable {
+    bytes32 private constant TYPE_HASH = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
+
+    struct EIP712Storage {
+        string _name;
+        string _version;
+    }
+
+    bytes32 private constant EIP712StorageLocation = 0xa16a46d94261c7517cc8ff89f61c0ce93598e3c849801011dee649a6a557d100;
+
+    function _getEIP712Storage() private pure returns (EIP712Storage storage $) {
+        assembly {
+            $.slot := EIP712StorageLocation
+        }
+    }
+
+    function __EIP712_init(string memory name, string memory version) internal onlyInitializing {
+        EIP712Storage storage $ = _getEIP712Storage();
+        $._name = name;
+        $._version = version;
+    }
+
+    function _domainSeparatorV4(uint256 chainId) internal view returns (bytes32) {
+        EIP712Storage storage $ = _getEIP712Storage();
+        return keccak256(abi.encode(TYPE_HASH, keccak256(bytes($._name)), keccak256(bytes($._version)), chainId, address(this)));
+    }
+
+    function _hashTypedDataV4(bytes32 structHash, uint256 chainId) internal view returns (bytes32) {
+        return keccak256(abi.encodePacked("\x19\x01", _domainSeparatorV4(chainId), structHash));
+    }
+}

package/src/version/ContractVersionBase.sol

@@ -0,0 +1,14 @@
+// This file is automatically generated by code; do not manually update
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {IVersionedContract} from "@zoralabs/shared-contracts/interfaces/IVersionedContract.sol";
+
+/// @title ContractVersionBase
+/// @notice Base contract for versioning contracts
+contract ContractVersionBase is IVersionedContract {
+    /// @notice The version of the contract
+    function contractVersion() external pure override returns (string memory) {
+        return "0.0.1";
+    }
+}