@zoralabs/comments-contracts 0.0.1 → 0.0.2

package/src/CommentsImplConstants.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+/// @title CommentsImplConstants
+/// @notice Constants for the CommentsImpl contract
+/// @author oveddan / IsabellaSmallcombe
+contract CommentsImplConstants {
+    /// @notice this is the zora creator multisig that can upgrade the contract
+    bytes32 public constant BACKFILLER_ROLE = keccak256("BACKFILLER_ROLE");
+    /// @notice allows to delegate comment
+    bytes32 public constant DELEGATE_COMMENTER = keccak256("DELEGATE_COMMENTER");
+    /// @notice permission bit for admin
+    uint256 public constant PERMISSION_BIT_ADMIN = 2 ** 1;
+    /// @notice Zora reward percentage
+    uint256 public constant ZORA_REWARD_PCT = 10;
+    /// @notice referrer reward percentage
+    uint256 public constant REFERRER_REWARD_PCT = 20;
+    /// @notice Zora reward percentage when there is no referrer
+    uint256 public constant ZORA_REWARD_NO_REFERRER_PCT = 30;
+    /// @notice BPS to percent conversion
+    uint256 internal constant BPS_TO_PERCENT_2_DECIMAL_PERCISION = 100;
+    /// @notice domain name for comments
+    string public constant DOMAIN_NAME = "Comments";
+    /// @notice domain version for comments
+    string public constant DOMAIN_VERSION = "1";
+    /// @notice Zora reward reason
+    bytes4 constant ZORA_REWARD_REASON = bytes4(keccak256("zoraRewardForCommentDeposited()"));
+    /// @notice referrer reward reason
+    bytes4 constant REFERRER_REWARD_REASON = bytes4(keccak256("referrerRewardForCommentDeposited()"));
+    /// @notice sparks recipient reward reason
+    bytes4 constant SPARKS_RECIPIENT_REWARD_REASON = bytes4(keccak256("sparksRecipientRewardForCommentDeposited()"));
+    /// @notice permint comment domain
+    bytes32 constant PERMIT_COMMENT_DOMAIN =
+        keccak256(
+            "PermitComment(address contractAddress,uint256 tokenId,address commenter,CommentIdentifier replyTo,string text,uint256 deadline,bytes32 nonce,address commenterSmartWallet,address referrer,uint32 sourceChainId,uint32 destinationChainId)CommentIdentifier(address contractAddress,uint256 tokenId,address commenter,bytes32 nonce)"
+        );
+    /// @notice comment identifier domain
+    bytes32 constant COMMENT_IDENTIFIER_DOMAIN = keccak256("CommentIdentifier(address contractAddress,uint256 tokenId,address commenter,bytes32 nonce)");
+    /// @notice permit spark comment domain
+    bytes32 constant PERMIT_SPARK_COMMENT_DOMAIN =
+        keccak256(
+            "PermitSparkComment(CommentIdentifier comment,address sparker,uint256 sparksQuantity,uint256 deadline,bytes32 nonce,address referrer,uint32 sourceChainId,uint32 destinationChainId)CommentIdentifier(address contractAddress,uint256 tokenId,address commenter,bytes32 nonce)"
+        );
+}

package/src/interfaces/ICallerAndCommenter.sol

@@ -0,0 +1,215 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {IComments} from "./IComments.sol";
+
+interface ICallerAndCommenter {
+    /// @notice Occurs when a signature is invalid
+    error InvalidSignature();
+
+    /// @notice Occurs when the deadline has expired
+    error ERC2612ExpiredSignature(uint256 deadline);
+    /// @notice Occurs when the destination chain ID doesn't match the current chain ID in a permit
+    error IncorrectDestinationChain(uint256 wrongDestinationChainId);
+
+    /// @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 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 Error thrown when attempting to buy tokens for a collection and tokenId that doesn't have an active sale
+    /// @param collection The address of the collection
+    /// @param tokenId The ID of the token
+    error SaleNotSet(address collection, uint256 tokenId);
+
+    /// @notice Error thrown when the wrong amount of ETH is sent
+    /// @param expected The expected amount of ETH
+    /// @param actual The actual amount of ETH sent
+    error WrongValueSent(uint256 expected, uint256 actual);
+
+    /// @notice Struct representing a permit for timed sale minting and commenting
+    struct PermitTimedSaleMintAndComment {
+        /// @dev The account that is creating the comment and minting tokens.
+        /// Must match the account that is signing the permit
+        address commenter;
+        /// @dev The number of tokens to mint
+        uint256 quantity;
+        /// @dev The address of the collection contract to mint from
+        address collection;
+        /// @dev The token ID to mint
+        uint256 tokenId;
+        /// @dev The address to receive mint referral rewards, if any
+        address mintReferral;
+        /// @dev The text of the comment
+        string comment;
+        /// @dev Permit deadline - execution of permit must be before this timestamp
+        uint256 deadline;
+        /// @dev Nonce to prevent replay attacks
+        bytes32 nonce;
+        /// @dev Chain ID where the permit was signed
+        uint32 sourceChainId;
+        /// @dev Chain ID where the permit should be executed
+        uint32 destinationChainId;
+    }
+
+    /// @notice Struct representing a permit for buying on secondary market and commenting
+    struct PermitBuyOnSecondaryAndComment {
+        /// @dev The account that is creating the comment and buying tokens.
+        /// Must match the account that is signing the permit
+        address commenter;
+        /// @dev The number of tokens to buy
+        uint256 quantity;
+        /// @dev The address of the collection contract to buy from
+        address collection;
+        /// @dev The token ID to buy
+        uint256 tokenId;
+        /// @dev The maximum amount of ETH to spend on the purchase
+        uint256 maxEthToSpend;
+        /// @dev The sqrt price limit for the swap
+        uint160 sqrtPriceLimitX96;
+        /// @dev The text of the comment
+        string comment;
+        /// @dev Permit deadline - execution of permit must be before this timestamp
+        uint256 deadline;
+        /// @dev Nonce to prevent replay attacks
+        bytes32 nonce;
+        /// @dev Chain ID where the permit was signed
+        uint32 sourceChainId;
+        /// @dev Chain ID where the permit should be executed
+        uint32 destinationChainId;
+    }
+
+    enum SwapDirection {
+        BUY,
+        SELL
+    }
+
+    /// @notice Emitted when tokens are bought or sold on the secondary market and a comment is added
+    /// @param commentId The unique identifier of the comment
+    /// @param commentIdentifier The struct containing details about the comment
+    /// @param quantity The number of tokens bought
+    /// @param comment The content of the comment
+    /// @param swapDirection The direction of the swap
+    event SwappedOnSecondaryAndCommented(
+        bytes32 indexed commentId,
+        IComments.CommentIdentifier commentIdentifier,
+        uint256 indexed quantity,
+        string comment,
+        SwapDirection indexed swapDirection
+    );
+
+    /// @notice Emitted when tokens are minted and a comment is added
+    /// @param commentId The unique identifier of the comment
+    /// @param commentIdentifier The struct containing details about the comment
+    /// @param quantity The number of tokens minted
+    /// @param text The content of the comment
+    event MintedAndCommented(bytes32 indexed commentId, IComments.CommentIdentifier commentIdentifier, uint256 quantity, string text);
+
+    /// @notice Initializes the upgradeable contract
+    /// @param owner of the contract that can perform upgrades
+    function initialize(address owner) external;
+
+    /// @notice Mints tokens and adds a comment, without needing to pay a spark for the comment.
+    /// @dev The payable amount should be the total mint fee. No spark value should be sent.
+    /// @param commenter The address of the commenter
+    /// @param quantity The number of tokens to mint
+    /// @param collection The address of the 1155 collection to mint from
+    /// @param tokenId The 1155 token Id to mint
+    /// @param mintReferral The address to receive mint referral rewards, if any
+    /// @param comment The comment to be added. If empty, no comment will be added.
+    /// @return The identifier of the newly created comment
+    function timedSaleMintAndComment(
+        address commenter,
+        uint256 quantity,
+        address collection,
+        uint256 tokenId,
+        address mintReferral,
+        string calldata comment
+    ) external payable returns (IComments.CommentIdentifier memory);
+
+    /// @notice Mints tokens and adds a comment, without needing to pay a spark for the comment. Attributes the
+    /// comment to the signer of the message.  Meant to be used for cross-chain commenting. where a permit
+    /// is signed in a chain and then executed in another chain.
+    /// @dev The signer must match the commenter field in the permit.
+    /// @param permit The PermitTimedSaleMintAndComment struct containing the permit data
+    /// @param signature The signature of the permit
+    /// @return The identifier of the newly created comment
+    function permitTimedSaleMintAndComment(
+        PermitTimedSaleMintAndComment calldata permit,
+        bytes calldata signature
+    ) external payable returns (IComments.CommentIdentifier memory);
+
+    /// @notice Hashes the permit data for a timed sale mint and comment operation
+    /// @param permit The PermitTimedSaleMintAndComment struct containing the permit data
+    /// @return bytes32 The hash of the permit data for signing
+    function hashPermitTimedSaleMintAndComment(PermitTimedSaleMintAndComment memory permit) external view returns (bytes32);
+
+    /// @notice Buys Zora 1155 tokens on secondary market and adds a comment, without needing to pay a spark for the comment.
+    /// @param commenter The address of the commenter. Must match the msg.sender.  Commenter will be the recipient of the bought tokens.
+    /// @param quantity The number of tokens to buy
+    /// @param collection The address of the 1155 collection
+    /// @param tokenId The 1155 token Id to buy
+    /// @param excessRefundRecipient The address to receive any excess ETH refund
+    /// @param maxEthToSpend The maximum amount of ETH to spend on the purchase
+    /// @param sqrtPriceLimitX96 The sqrt price limit for the swap
+    /// @param comment The comment to be added
+    /// @return The identifier of the newly created comment
+    /// @dev This function can only be called by the commenter themselves
+    function buyOnSecondaryAndComment(
+        address commenter,
+        uint256 quantity,
+        address collection,
+        uint256 tokenId,
+        address payable excessRefundRecipient,
+        uint256 maxEthToSpend,
+        uint160 sqrtPriceLimitX96,
+        string calldata comment
+    ) external payable returns (IComments.CommentIdentifier memory);
+
+    /// @notice Buys tokens on secondary market and adds a comment using a permit
+    /// @dev The signer must match the commenter field in the permit.
+    /// @param permit The PermitBuyOnSecondaryAndComment struct containing the permit data
+    /// @param signature The signature of the permit
+    /// @return The identifier of the newly created comment
+    function permitBuyOnSecondaryAndComment(
+        PermitBuyOnSecondaryAndComment calldata permit,
+        bytes calldata signature
+    ) external payable returns (IComments.CommentIdentifier memory);
+
+    /// @notice Hashes the permit data for a buy on secondary and comment operation
+    /// @param permit The PermitBuyOnSecondaryAndComment struct containing the permit data
+    /// @return bytes32 The hash of the permit data for signing
+    function hashPermitBuyOnSecondaryAndComment(PermitBuyOnSecondaryAndComment memory permit) external view returns (bytes32);
+
+    /// @notice Sells Zora 1155 tokens on secondary market and adds a comment. A spark needs to be paid for the comment, if a comment
+    /// is to be added.
+    /// @param commenter The address of the commenter. Must match the msg.sender. Commenter will be the seller of the tokens.
+    /// @param quantity The number of tokens to sell
+    /// @param collection The address of the 1155 collection
+    /// @param tokenId The 1155 token Id to sell
+    /// @param recipient The address to receive the ETH proceeds
+    /// @param minEthToAcquire The minimum amount of ETH to receive from the sale
+    /// @param sqrtPriceLimitX96 The sqrt price limit for the swap
+    /// @param comment The comment to be added
+    /// @return The identifier of the newly created comment
+    /// @dev This function can only be called by the commenter themselves
+    function sellOnSecondaryAndComment(
+        address commenter,
+        uint256 quantity,
+        address collection,
+        uint256 tokenId,
+        address payable recipient,
+        uint256 minEthToAcquire,
+        uint160 sqrtPriceLimitX96,
+        string calldata comment
+    ) external payable returns (IComments.CommentIdentifier memory);
+
+    /// @notice Returns the address of the comments contract
+    /// @return address The address of the comments contract
+    function comments() external view returns (IComments);
+}

package/src/interfaces/IComments.sol

@@ -1,7 +1,11 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.23;
 
+/// @title IComments
+/// @notice Interface for the Comments contract, which allows for comments and sparking (liking with value) on Zora 1155 posts
+/// @author oveddan / IsabellaSmallcombe
 interface IComments {
+    /// @notice Struct representing a unique identifier for a comment
     struct CommentIdentifier {
         address commenter;
         address contractAddress;
@@ -9,41 +13,112 @@ interface IComments {
         bytes32 nonce;
     }
 
+    /// @notice Struct representing a comment
     struct Comment {
         // has this comment been created
         bool exists;
         // total sparks for this comment
-        uint64 totalSparks;
+        uint256 totalSparks;
     }
 
-    // Event emitted when a comment is created
+    /// @notice Struct representing a permit for creating a comment
+    struct PermitComment {
+        // The account that is creating the comment.
+        // Must match the account that is signing the permit
+        address commenter;
+        // If the commenter, has a smart wallet, the smart wallet address.
+        // If not, zero address.  If set, this address can be checked
+        // to see if the token is owned by the smart wallet.
+        address commenterSmartWallet;
+        // The contract address that is being commented on
+        address contractAddress;
+        // The token ID that is being commented on
+        uint256 tokenId;
+        // The comment identifier of the comment being replied to
+        CommentIdentifier replyTo;
+        // The text of the comment
+        string text;
+        // Referrer address - will get referral reward from the spark
+        address referrer;
+        // Permit deadline - execution of permit must be before this timestamp
+        uint256 deadline;
+        // Nonce to prevent replay attacks
+        bytes32 nonce;
+        // Chain the permit was signed on
+        uint32 sourceChainId;
+        // Chain to execute the permit on
+        uint32 destinationChainId;
+    }
+
+    /// @notice Struct representing a permit for sparking a comment
+    struct PermitSparkComment {
+        // Comment that is being sparked
+        CommentIdentifier comment;
+        // Address of the user that is sparking the comment.
+        // Must match the address that is signing the permit
+        address sparker;
+        // Number of sparks to spark
+        uint256 sparksQuantity;
+        // Permit deadline - execution of permit must be before this timestamp
+        uint256 deadline;
+        // Nonce to prevent replay attacks
+        bytes32 nonce;
+        // Referrer address - will get referral reward from the spark
+        address referrer;
+        // Chain the permit was signed on
+        uint32 sourceChainId;
+        // Chain to execute the permit on
+        uint32 destinationChainId;
+    }
+
+    /// @notice Event emitted when a comment is created
+    /// @param commentId Unique ID for the comment, generated from a hash of the commentIdentifier
+    /// @param commentIdentifier Identifier for the comment, containing details about the comment
+    /// @param replyToId Unique ID of the comment being replied to (if any)
+    /// @param replyTo Identifier of the comment being replied to (if any)
+    /// @param sparksQuantity Number of sparks associated with this comment
+    /// @param text The actual text content of the comment
+    /// @param timestamp Timestamp when the comment was created
+    /// @param referrer Address of the referrer who referred the commenter, if any
     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
+        bytes32 indexed commentId, // Unique ID for the comment, generated from a hash of the commentIdentifier
+        CommentIdentifier commentIdentifier, // Identifier for the comment, containing details about the comment
+        bytes32 replyToId, // Unique ID of the comment being replied to (if any)
+        CommentIdentifier replyTo, // Identifier of the comment being replied to (if any)
+        uint256 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
+        address referrer // Address of the referrer who referred the commenter, if any
     );
 
-    // Event emitted when a comment is backfilled
+    /// @notice Event emitted when a comment is backfilled
+    /// @param commentId Unique identifier for the backfilled comment
+    /// @param commentIdentifier Identifier for the comment
+    /// @param text The actual text content of the backfilled comment
+    /// @param timestamp Timestamp when the original comment was created
+    /// @param originalTransactionId Transaction ID of the original comment (before backfilling)
     event BackfilledComment(
         bytes32 indexed commentId, // Unique identifier for the backfilled comment
-        CommentIdentifier comment, // Struct containing details about the comment and commenter
+        CommentIdentifier commentIdentifier, // Identifier for the comment
         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
+    /// @notice Event emitted when a comment is Sparked
+    /// @param commentId Unique identifier of the comment being sparked
+    /// @param commentIdentifier Struct containing details about the comment and commenter
+    /// @param sparksQuantity Number of sparks added to the comment
+    /// @param sparker Address of the user who sparked the comment
+    /// @param timestamp Timestamp when the spark action occurred
+    /// @param referrer Address of the referrer who referred the sparker, if any
     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
+        uint256 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
+        uint256 timestamp, // Timestamp when the spark action occurred
+        address referrer // Address of the referrer who referred the sparker, if any
     );
 
     /// @notice Occurs when attempting to add a comment that already exists
@@ -93,64 +168,136 @@ interface IComments {
     /// @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.
-     */
+    /// @notice Occurs when the commenter is not a smart wallet owner
+    error NotSmartWalletOwner();
+
+    /// @notice Occurs when the address is not a smart wallet
+    error NotSmartWallet();
+
+    /// @notice Occurs when the deadline has expired
     error ERC2612ExpiredSignature(uint256 deadline);
 
+    /// @notice Occurs when the funds recipient does not exist
+    error NoFundsRecipient();
+
+    /// @notice Address cannot be zero
+    error AddressZero();
+
+    /// @notice Creates a new comment
+    /// @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 commenterSmartWalletOwner If the commenter has a smart wallet, the smart wallet owner address
+    /// @param referrer The address of the referrer (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 commenterSmartWalletOwner,
         address referrer
     ) external payable returns (CommentIdentifier memory);
 
+    /// @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 commenterSmartWalletOwner If the commenter has a smart wallet, the smart wallet owner address
+    /// @param referrer The address of the referrer (if any)
+    /// @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 returns (CommentIdentifier memory);
+        CommentIdentifier calldata replyTo,
+        address commenterSmartWalletOwner,
+        address referrer
+    ) external payable returns (CommentIdentifier memory, bytes32 commentId);
 
-    function sparkComment(CommentIdentifier calldata commentIdentifier, uint64 sparksQuantity, address referrer) external payable;
+    function initialize(address commentsAdmin, address backfiller, address[] calldata delegateCommenters) external;
 
+    /// @notice Sparks a comment
+    /// @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, uint256 sparksQuantity, address referrer) external payable;
+
+    /// @notice Returns the value of a single spark
+    /// @return The value of a single spark
     function sparkValue() external view returns (uint256);
 
+    /// @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 calldata commentIdentifier) external view returns (bytes32);
 
+    /// @notice Returns the next nonce for comment creation
+    /// @return The next nonce
     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;
-    }
+    /// @notice Returns the implementation address of the contract
+    /// @return The implementation address
+    function implementation() external view returns (address);
 
-    struct PermitSparkComment {
-        CommentIdentifier comment;
-        address sparker;
-        uint64 sparksQuantity;
-        uint256 deadline;
-        bytes32 nonce;
-        address referrer;
-        uint256 sourceChainId;
-        uint256 destinationChainId;
-    }
+    /// @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);
+
+    /// @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) external view returns (bytes32 commentId, bool 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) external view returns (bytes32 commentId);
+
+    /// @notice Hashes a permit comment struct for signing
+    /// @param permit The permit comment struct
+    /// @return The hash to sign
+    function hashPermitComment(PermitComment calldata permit) external view returns (bytes32);
+
+    /// @notice Creates a comment on behalf of another account using a signed message
+    /// @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) external payable;
+
+    /// @notice Hashes a permit spark comment struct for signing
+    /// @param permit The permit spark comment struct
+    /// @return The hash to sign
+    function hashPermitSparkComment(PermitSparkComment calldata permit) external view returns (bytes32);
+
+    /// @notice Sparks a comment on behalf of another account using a signed message
+    /// @param permit The permit spark comment struct
+    /// @param signature The signature of the permit
+    function permitSparkComment(PermitSparkComment calldata permit, bytes calldata signature) external payable;
+
+    /// @notice Backfills comments created by other contracts
+    /// @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
+    ) external;
 }

package/src/interfaces/IMultiOwnable.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+/// Extracted interface from Coinbase Smart Wallet's MultiOwnable contract,
+/// which we use to check if an address is an owner of the smart wallet
+/// in tests without having to include the entire contract in the package
+/// Original function can be seen here: https://github.com/coinbase/talaria/blob/main/contracts/src/MultiOwnable.sol
+interface IMultiOwnable {
+    function isOwnerAddress(address account) external view returns (bool);
+}

package/src/interfaces/ISecondarySwap.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+/*
+
+
+             ░░░░░░░░░░░░░░              
+        ░░▒▒░░░░░░░░░░░░░░░░░░░░        
+      ░░▒▒▒▒░░░░░░░░░░░░░░░░░░░░░░      
+    ░░▒▒▒▒░░░░░░░░░░░░░░    ░░░░░░░░    
+   ░▓▓▒▒▒▒░░░░░░░░░░░░        ░░░░░░░    
+  ░▓▓▓▒▒▒▒░░░░░░░░░░░░        ░░░░░░░░  
+  ░▓▓▓▒▒▒▒░░░░░░░░░░░░░░    ░░░░░░░░░░  
+  ░▓▓▓▒▒▒▒▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░░  
+  ░▓▓▓▓▓▒▒▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░  
+   ░▓▓▓▓▒▒▒▒▒▒░░░░░░░░░░░░░░░░░░░░░░░  
+    ░░▓▓▓▓▒▒▒▒▒▒░░░░░░░░░░░░░░░░░░░░    
+    ░░▓▓▓▓▓▓▒▒▒▒▒▒▒▒░░░░░░░░░▒▒▒▒▒░░    
+      ░░▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░░      
+          ░░▓▓▓▓▓▓▓▓▓▓▓▓▒▒░░░          
+
+               OURS TRULY,
+
+
+*/
+
+interface ISecondarySwap {
+    // function sell1155(address erc20zAddress, uint256 num1155ToSell, address payable recipient, uint256 minEthToAcquire, uint160 sqrtPriceLimitX96) external;
+
+    function buy1155(
+        address erc20zAddress,
+        uint256 num1155ToBuy,
+        address payable recipient,
+        address payable excessRefundRecipient,
+        uint256 maxEthToSpend,
+        uint160 sqrtPriceLimitX96
+    ) external payable;
+
+    error SaleNotSet();
+}

package/src/interfaces/IZoraCreator1155.sol

@@ -2,11 +2,16 @@
 pragma solidity ^0.8.23;
 
 import {IERC1155} from "@openzeppelin/contracts/interfaces/IERC1155.sol";
+import {IZoraCreator1155TypesV1} from "./IZoraCreator1155TypesV1.sol";
 
-interface IZoraCreator1155 is IERC1155 {
+interface IZoraCreator1155 is IERC1155, IZoraCreator1155TypesV1 {
     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);
+
+    function config() external view returns (address owner, uint96 __gap1, address payable fundsRecipient, uint96 __gap2, address transferHook, uint96 __gap3);
+
+    function owner() external view returns (address);
 }