@zoralabs/comments-contracts 0.0.1 → 0.0.2

package/test/Comments_permit.t.sol

@@ -11,10 +11,11 @@ import {IProtocolRewards} from "@zoralabs/protocol-rewards/src/interfaces/IProto
 import {ProtocolRewards} from "./mocks/ProtocolRewards.sol";
 import {CommentsTestBase} from "./CommentsTestBase.sol";
 import {UnorderedNoncesUpgradeable} from "@zoralabs/shared-contracts/utils/UnorderedNoncesUpgradeable.sol";
+import {MockMultiOwnable} from "./Comments_smartWallet.t.sol";
 
 contract CommentsPermitTest is CommentsTestBase {
     function testPermitComment() public {
-        IComments.PermitComment memory permitComment = _createPermitComment(collectorWithToken, "test comment", 3);
+        IComments.PermitComment memory permitComment = _createPermitComment(collectorWithToken, "test comment");
         bytes memory signature = _signPermitComment(permitComment, collectorWithTokenPrivateKey);
 
         IComments.CommentIdentifier memory expectedCommentIdentifier = _expectedCommentIdentifier(
@@ -27,7 +28,7 @@ contract CommentsPermitTest is CommentsTestBase {
 
         // any account can execute the permit comment on behalf of the collectorWithToken, but they must have enough eth to do so.
         address executor = makeAddr("executor");
-        vm.deal(executor, permitComment.sparksQuantity * SPARKS_VALUE);
+        vm.deal(executor, SPARKS_VALUE);
 
         vm.expectEmit(true, true, true, true);
         emit IComments.Commented(
@@ -35,7 +36,7 @@ contract CommentsPermitTest is CommentsTestBase {
             expectedCommentIdentifier,
             bytes32(0),
             permitComment.replyTo,
-            permitComment.sparksQuantity,
+            1,
             permitComment.text,
             block.timestamp,
             permitComment.referrer
@@ -47,7 +48,7 @@ contract CommentsPermitTest is CommentsTestBase {
     }
 
     function testPermitComment_NonceUsedTwice() public {
-        IComments.PermitComment memory permitComment = _createPermitComment(collectorWithToken, "test comment", 3);
+        IComments.PermitComment memory permitComment = _createPermitComment(collectorWithToken, "test comment");
         bytes memory signature = _signPermitComment(permitComment, collectorWithTokenPrivateKey);
 
         _setupTokenAndSparks(permitComment);
@@ -62,7 +63,7 @@ contract CommentsPermitTest is CommentsTestBase {
     }
 
     function testPermitComment_DeadlineExpired() public {
-        IComments.PermitComment memory permitComment = _createPermitComment(collectorWithToken, "test comment", 3);
+        IComments.PermitComment memory permitComment = _createPermitComment(collectorWithToken, "test comment");
         bytes memory signature = _signPermitComment(permitComment, collectorWithTokenPrivateKey);
 
         _setupTokenAndSparks(permitComment);
@@ -71,7 +72,7 @@ contract CommentsPermitTest is CommentsTestBase {
         vm.warp(permitComment.deadline + 1);
 
         address executor = makeAddr("executor");
-        vm.deal(executor, permitComment.sparksQuantity * SPARKS_VALUE);
+        vm.deal(executor, SPARKS_VALUE);
         vm.expectRevert(abi.encodeWithSelector(IComments.ERC2612ExpiredSignature.selector, permitComment.deadline));
         _executePermitComment(executor, permitComment, signature);
     }
@@ -81,7 +82,7 @@ contract CommentsPermitTest is CommentsTestBase {
         uint256 wrongSignerPrivateKey;
         (wrongSigner, wrongSignerPrivateKey) = makeAddrAndKey("wrongSigner");
 
-        IComments.PermitComment memory permitComment = _createPermitComment(collectorWithToken, "test comment", 3);
+        IComments.PermitComment memory permitComment = _createPermitComment(collectorWithToken, "test comment");
         bytes memory wrongSignature = _signPermitComment(permitComment, wrongSignerPrivateKey);
 
         _setupTokenAndSparks(permitComment);
@@ -90,26 +91,101 @@ contract CommentsPermitTest is CommentsTestBase {
         _executePermitComment(collectorWithToken, permitComment, wrongSignature);
     }
 
-    function testPermitComment_ZeroSparks() public {
-        IComments.PermitComment memory permitComment = _createPermitComment(collectorWithToken, "test comment", 0);
+    function testPermitComment_ZeroSparks_Collector() public {
+        IComments.PermitComment memory permitComment = _createPermitComment(collectorWithToken, "test comment");
         bytes memory signature = _signPermitComment(permitComment, collectorWithTokenPrivateKey);
 
         _setupTokenAndSparks(permitComment);
 
         vm.expectRevert(IComments.MustSendAtLeastOneSpark.selector);
-        _executePermitComment(collectorWithToken, permitComment, signature);
+        vm.prank(collectorWithToken);
+        comments.permitComment{value: 0}(permitComment, signature);
+    }
+
+    function testPermitComment_ZeroSparks_Creator() public {
+        IComments.PermitComment memory permitComment = _createPermitComment(tokenAdmin, "test comment");
+        bytes memory signature = _signPermitComment(permitComment, tokenAdminPrivateKey);
+
+        _setupTokenAndSparks(permitComment);
+
+        bytes32 expectedNonce = comments.nextNonce();
+
+        // any account can execute the permit comment on behalf of the tokenAdmin,
+        // it should be executed with 0 sparks
+        vm.prank(makeAddr("random account"));
+        comments.permitComment{value: 0}(permitComment, signature);
+
+        IComments.CommentIdentifier memory expectedCommentIdentifier = IComments.CommentIdentifier({
+            commenter: tokenAdmin,
+            contractAddress: address(mock1155),
+            tokenId: tokenId1,
+            nonce: expectedNonce
+        });
+        _assertCommentExists(expectedCommentIdentifier);
     }
 
     function testPermitComment_Not1155Holder() public {
-        IComments.PermitComment memory permitComment = _createPermitComment(collectorWithToken, "test comment", 3);
+        IComments.PermitComment memory permitComment = _createPermitComment(collectorWithToken, "test comment");
         bytes memory signature = _signPermitComment(permitComment, collectorWithTokenPrivateKey);
 
         address executor = makeAddr("executor");
-        vm.deal(executor, permitComment.sparksQuantity * SPARKS_VALUE);
+        vm.deal(executor, SPARKS_VALUE);
         vm.expectRevert(IComments.NotTokenHolderOrAdmin.selector);
         _executePermitComment(executor, permitComment, signature);
     }
 
+    function testPermitComment_SmartWalletOwner() public {
+        // Test scenario:
+        // We want to enable a smart wallet owner to comment when the smart wallet owns the token.
+        // - The smart wallet owns the 1155 token
+        // - privy account is an owner of the smart wallet
+        // - privy account is the one that signs the message
+        // - The comment is attributed to privy account (the smart wallet owner)
+        // We create a permit where:
+        // - commenter is privy account (smart wallet owner)
+        // - commenterSmartWallet is the smart wallet address
+        // - Privy account signs the message
+        // This should be a valid scenario, allowing a smart wallet owner to comment using a token owned by the smart wallet.
+        (address privyAccount, uint256 privyPrivateKey) = makeAddrAndKey("privy");
+
+        address smartWallet = address(new MockMultiOwnable(privyAccount));
+
+        mock1155.mint(smartWallet, tokenId1, 1, "");
+
+        IComments.PermitComment memory permitComment = IComments.PermitComment({
+            // comment will be attributed to the smart wallet - it should be the one that
+            // has the signature checked against it.
+            commenter: privyAccount,
+            contractAddress: address(mock1155),
+            tokenId: tokenId1,
+            replyTo: IComments.CommentIdentifier({commenter: address(0), contractAddress: address(0), tokenId: 0, nonce: bytes32(0)}),
+            text: "smart wallet comment",
+            deadline: uint48(block.timestamp + 1000),
+            nonce: bytes32(0),
+            referrer: address(0),
+            sourceChainId: uint32(100),
+            destinationChainId: uint32(block.chainid),
+            // collectorWithToken is the smart wallet owner - this is the account that actually owns the 1155 token.
+            commenterSmartWallet: smartWallet
+        });
+
+        // sign the permit - but we have the another account (privy) sign for the smart wallet, since it is also an owner
+        bytes memory signature = _signPermitComment(permitComment, privyPrivateKey);
+
+        IComments.CommentIdentifier memory expectedCommentIdentifier = _expectedCommentIdentifier(
+            permitComment.contractAddress,
+            permitComment.tokenId,
+            // privy account is the one that signs the message, but the smart wallet is the one that is commenting
+            privyAccount
+        );
+
+        address executor = makeAddr("executor");
+        vm.deal(executor, SPARKS_VALUE);
+        _executePermitComment(executor, permitComment, signature);
+
+        _assertCommentExists(expectedCommentIdentifier);
+    }
+
     function testPermitSparkCommentSparksComment() public {
         IComments.PermitSparkComment memory permitSparkComment = _postCommentAndCreatePermitSparkComment(sparker, 3);
         bytes memory signature = _signPermitSparkComment(permitSparkComment, sparkerPrivateKey);
@@ -119,16 +195,21 @@ contract CommentsPermitTest is CommentsTestBase {
         address executor = makeAddr("executor");
         vm.deal(executor, permitSparkComment.sparksQuantity * SPARKS_VALUE);
 
-        bytes32 commentId = comments.hashCommentIdentifier(permitSparkComment.comment);
-
-        uint256 beforeSparksCount = comments.commentSparksQuantity(commentId);
+        uint256 beforeSparksCount = comments.commentSparksQuantity(permitSparkComment.comment);
 
         vm.expectEmit(true, true, true, true);
-        emit IComments.SparkedComment(commentId, permitSparkComment.comment, permitSparkComment.sparksQuantity, sparker, block.timestamp);
+        emit IComments.SparkedComment(
+            comments.hashCommentIdentifier(permitSparkComment.comment),
+            permitSparkComment.comment,
+            permitSparkComment.sparksQuantity,
+            sparker,
+            block.timestamp,
+            permitSparkComment.referrer
+        );
 
         _executePermitSparkComment(executor, permitSparkComment, signature);
 
-        uint256 afterSparksCount = comments.commentSparksQuantity(commentId);
+        uint256 afterSparksCount = comments.commentSparksQuantity(permitSparkComment.comment);
         assertEq(afterSparksCount, beforeSparksCount + permitSparkComment.sparksQuantity);
     }
 
@@ -204,10 +285,10 @@ contract CommentsPermitTest is CommentsTestBase {
     }
 
     function testPermitCommentCrossChain() public {
-        uint256 sourceChainId = 1; // Ethereum mainnet
-        uint256 destinationChainId = block.chainid;
+        uint32 sourceChainId = 1; // Ethereum mainnet
+        uint32 destinationChainId = uint32(block.chainid);
 
-        IComments.PermitComment memory permitComment = _createPermitComment(collectorWithToken, "cross-chain comment", 3);
+        IComments.PermitComment memory permitComment = _createPermitComment(collectorWithToken, "cross-chain comment");
         permitComment.sourceChainId = sourceChainId;
         permitComment.destinationChainId = destinationChainId;
 
@@ -222,7 +303,7 @@ contract CommentsPermitTest is CommentsTestBase {
         _setupTokenAndSparks(permitComment);
 
         address executor = makeAddr("executor");
-        vm.deal(executor, permitComment.sparksQuantity * SPARKS_VALUE);
+        vm.deal(executor, SPARKS_VALUE);
 
         vm.expectEmit(true, true, true, true);
         emit IComments.Commented(
@@ -230,7 +311,7 @@ contract CommentsPermitTest is CommentsTestBase {
             expectedCommentIdentifier,
             bytes32(0),
             permitComment.replyTo,
-            permitComment.sparksQuantity,
+            1,
             permitComment.text,
             block.timestamp,
             permitComment.referrer
@@ -242,10 +323,10 @@ contract CommentsPermitTest is CommentsTestBase {
     }
 
     function testPermitCommentCrossChainInvalidDestination() public {
-        uint256 sourceChainId = 1; // Ethereum mainnet
-        uint256 invalidDestinationChainId = 42; // Some other chain ID
+        uint32 sourceChainId = 1; // Ethereum mainnet
+        uint32 invalidDestinationChainId = 42; // Some other chain ID
 
-        IComments.PermitComment memory permitComment = _createPermitComment(collectorWithToken, "invalid cross-chain comment", 3);
+        IComments.PermitComment memory permitComment = _createPermitComment(collectorWithToken, "invalid cross-chain comment");
         permitComment.sourceChainId = sourceChainId;
         permitComment.destinationChainId = invalidDestinationChainId;
 
@@ -254,15 +335,15 @@ contract CommentsPermitTest is CommentsTestBase {
         _setupTokenAndSparks(permitComment);
 
         address executor = makeAddr("executor");
-        vm.deal(executor, permitComment.sparksQuantity * SPARKS_VALUE);
+        vm.deal(executor, SPARKS_VALUE);
 
         vm.expectRevert(abi.encodeWithSelector(IComments.IncorrectDestinationChain.selector, invalidDestinationChainId));
         _executePermitComment(executor, permitComment, signature);
     }
 
     function testPermitSparkCommentCrossChain() public {
-        uint256 sourceChainId = 1; // Ethereum mainnet
-        uint256 destinationChainId = block.chainid;
+        uint32 sourceChainId = 1; // Ethereum mainnet
+        uint32 destinationChainId = uint32(block.chainid);
 
         IComments.PermitSparkComment memory permitSparkComment = _postCommentAndCreatePermitSparkComment(sparker, 3);
         permitSparkComment.sourceChainId = sourceChainId;
@@ -275,22 +356,28 @@ contract CommentsPermitTest is CommentsTestBase {
         address executor = makeAddr("executor");
         vm.deal(executor, permitSparkComment.sparksQuantity * SPARKS_VALUE);
 
-        bytes32 commentId = comments.hashCommentIdentifier(permitSparkComment.comment);
+        uint256 beforeSparksCount = comments.commentSparksQuantity(permitSparkComment.comment);
 
-        uint256 beforeSparksCount = comments.commentSparksQuantity(commentId);
+        bytes32 commentId = comments.hashCommentIdentifier(permitSparkComment.comment);
 
         vm.expectEmit(true, true, true, true);
-        emit IComments.SparkedComment(commentId, permitSparkComment.comment, permitSparkComment.sparksQuantity, sparker, block.timestamp);
-
+        emit IComments.SparkedComment(
+            commentId,
+            permitSparkComment.comment,
+            permitSparkComment.sparksQuantity,
+            sparker,
+            block.timestamp,
+            permitSparkComment.referrer
+        );
         _executePermitSparkComment(executor, permitSparkComment, signature);
 
-        uint256 afterSparksCount = comments.commentSparksQuantity(commentId);
+        uint256 afterSparksCount = comments.commentSparksQuantity(permitSparkComment.comment);
         assertEq(afterSparksCount, beforeSparksCount + permitSparkComment.sparksQuantity);
     }
 
     function testPermitSparkCommentCrossChainInvalidDestination() public {
-        uint256 sourceChainId = 1; // Ethereum mainnet
-        uint256 invalidDestinationChainId = 42; // Some other chain ID
+        uint32 sourceChainId = 1; // Ethereum mainnet
+        uint32 invalidDestinationChainId = 42; // Some other chain ID
 
         IComments.PermitSparkComment memory permitSparkComment = _postCommentAndCreatePermitSparkComment(sparker, 3);
         permitSparkComment.sourceChainId = sourceChainId;
@@ -312,7 +399,7 @@ contract CommentsPermitTest is CommentsTestBase {
         address commenter = makeAddr("commenter_b");
         IComments.CommentIdentifier memory commentIdentifier = _mockComment(commenter, emptyReplyTo);
 
-        return _createPermitSparkComment(commentIdentifier, _sparker, sparksQuantity, block.chainid, block.chainid);
+        return _createPermitSparkComment(commentIdentifier, _sparker, sparksQuantity, uint32(block.chainid), uint32(block.chainid));
     }
 
     // Helper functions
@@ -320,8 +407,8 @@ contract CommentsPermitTest is CommentsTestBase {
         IComments.CommentIdentifier memory commentIdentifier,
         address _sparker,
         uint64 sparksQuantity,
-        uint256 sourceChainId,
-        uint256 destinationChainId
+        uint32 sourceChainId,
+        uint32 destinationChainId
     ) internal returns (IComments.PermitSparkComment memory) {
         return
             IComments.PermitSparkComment({
@@ -353,7 +440,7 @@ contract CommentsPermitTest is CommentsTestBase {
     }
 
     // Helper functions
-    function _createPermitComment(address commenter, string memory text, uint64 sparksQuantity) internal returns (IComments.PermitComment memory) {
+    function _createPermitComment(address commenter, string memory text) internal returns (IComments.PermitComment memory) {
         return
             IComments.PermitComment({
                 contractAddress: address(mock1155),
@@ -361,23 +448,23 @@ contract CommentsPermitTest is CommentsTestBase {
                 commenter: commenter,
                 replyTo: emptyCommentIdentifier,
                 text: text,
-                sparksQuantity: sparksQuantity,
                 deadline: block.timestamp + 100,
                 nonce: bytes32("1"),
                 referrer: makeAddr("referrer"),
-                sourceChainId: block.chainid,
-                destinationChainId: block.chainid
+                sourceChainId: uint32(block.chainid),
+                destinationChainId: uint32(block.chainid),
+                commenterSmartWallet: address(0)
             });
     }
 
     function _setupTokenAndSparks(IComments.PermitComment memory permitComment) internal {
         mock1155.mint(permitComment.commenter, permitComment.tokenId, 1, "");
-        vm.deal(permitComment.commenter, permitComment.sparksQuantity * SPARKS_VALUE);
+        vm.deal(permitComment.commenter, SPARKS_VALUE);
     }
 
     function _executePermitComment(address executor, IComments.PermitComment memory permitComment, bytes memory signature) internal {
         vm.prank(executor);
-        comments.permitComment{value: permitComment.sparksQuantity * SPARKS_VALUE}(permitComment, signature);
+        comments.permitComment{value: SPARKS_VALUE}(permitComment, signature);
     }
 
     function _assertCommentExists(IComments.CommentIdentifier memory commentIdentifier) internal view {

package/test/Comments_smartWallet.t.sol

@@ -0,0 +1,152 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {CommentsTestBase} from "./CommentsTestBase.sol";
+import {IMultiOwnable} from "../src/interfaces/IMultiOwnable.sol";
+import {IComments} from "../src/interfaces/IComments.sol";
+import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+import {ERC1155Holder} from "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";
+
+contract MockMultiOwnable is IMultiOwnable, ERC1155Holder {
+    bytes4 internal constant MAGIC_VALUE = bytes4(keccak256("isValidSignature(bytes32,bytes)"));
+    mapping(address => bool) public isOwner;
+
+    constructor(address _owner) {
+        isOwner[_owner] = true;
+    }
+
+    function addOwner(address _owner) external {
+        isOwner[_owner] = true;
+    }
+
+    function isValidSignature(bytes32 _messageHash, bytes memory _signature) public view returns (bytes4 magicValue) {
+        address signatory = ECDSA.recover(_messageHash, _signature);
+
+        if (isOwner[signatory]) {
+            return MAGIC_VALUE;
+        } else {
+            return bytes4(0);
+        }
+    }
+
+    function isOwnerAddress(address account) external view returns (bool) {
+        return isOwner[account];
+    }
+}
+
+contract Comments_smartWallet is CommentsTestBase {
+    function test_commentWithSmartWalletOwner_whenHolder() public {
+        address smartWallet = address(new MockMultiOwnable(address(collectorWithoutToken)));
+
+        mock1155.mint(smartWallet, tokenId1, 1, "");
+
+        IComments.CommentIdentifier memory expectedCommentIdentifier = _expectedCommentIdentifier(address(mock1155), tokenId1, collectorWithoutToken);
+
+        vm.expectEmit(true, true, true, true);
+        emit IComments.Commented(
+            comments.hashCommentIdentifier(expectedCommentIdentifier),
+            expectedCommentIdentifier,
+            0,
+            emptyCommentIdentifier,
+            1,
+            "test comment",
+            block.timestamp,
+            address(0)
+        );
+        vm.prank(collectorWithoutToken);
+        vm.deal(collectorWithoutToken, SPARKS_VALUE);
+        comments.comment{value: SPARKS_VALUE}({
+            commenter: collectorWithoutToken,
+            contractAddress: address(mock1155),
+            tokenId: tokenId1,
+            text: "test comment",
+            replyTo: emptyCommentIdentifier,
+            commenterSmartWallet: smartWallet,
+            referrer: address(0)
+        });
+    }
+
+    function test_commentWithSmartWalletOwner_whenCreator() public {
+        address smartWallet = address(new MockMultiOwnable(address(collectorWithoutToken)));
+
+        uint256 tokenId = 10;
+        mock1155.createToken(tokenId, address(smartWallet));
+
+        IComments.CommentIdentifier memory expectedCommentIdentifier = _expectedCommentIdentifier(address(mock1155), tokenId, collectorWithoutToken);
+
+        vm.prank(collectorWithoutToken);
+        comments.comment({
+            commenter: collectorWithoutToken,
+            contractAddress: address(mock1155),
+            tokenId: tokenId,
+            text: "test comment",
+            replyTo: emptyCommentIdentifier,
+            commenterSmartWallet: smartWallet,
+            referrer: address(0)
+        });
+
+        // check that comment was created
+        (, bool exists) = comments.hashAndCheckCommentExists(expectedCommentIdentifier);
+        assertTrue(exists);
+    }
+
+    function test_commentWithSmartWalletOwner_revertsWhenNotHolder() public {
+        address smartWallet = address(new MockMultiOwnable(address(collectorWithoutToken)));
+
+        IComments.CommentIdentifier memory emptyReplyTo;
+
+        vm.expectRevert(abi.encodeWithSelector(IComments.NotTokenHolderOrAdmin.selector));
+        vm.prank(collectorWithoutToken);
+        vm.deal(collectorWithoutToken, SPARKS_VALUE);
+        comments.comment{value: SPARKS_VALUE}({
+            commenter: collectorWithoutToken,
+            contractAddress: address(mock1155),
+            tokenId: tokenId1,
+            text: "test comment",
+            replyTo: emptyReplyTo,
+            commenterSmartWallet: smartWallet,
+            referrer: address(0)
+        });
+    }
+
+    function test_commentWithSmartWalletOwner_revertsWhenNotOwner() public {
+        address smartWallet = address(new MockMultiOwnable(address(makeAddr("notOwner"))));
+
+        mock1155.mint(smartWallet, tokenId1, 1, "");
+
+        IComments.CommentIdentifier memory emptyReplyTo;
+
+        vm.expectRevert(IComments.NotSmartWalletOwner.selector);
+        vm.prank(collectorWithoutToken);
+        vm.deal(collectorWithoutToken, SPARKS_VALUE);
+        comments.comment{value: SPARKS_VALUE}({
+            commenter: collectorWithoutToken,
+            contractAddress: address(mock1155),
+            tokenId: tokenId1,
+            text: "test comment",
+            replyTo: emptyReplyTo,
+            commenterSmartWallet: smartWallet,
+            referrer: address(0)
+        });
+    }
+
+    function test_commentWithSmartWalletOwner_revertsWhenNotSmartWallet() public {
+        address smartWallet = makeAddr("smartWallet");
+
+        mock1155.mint(smartWallet, tokenId1, 1, "");
+
+        IComments.CommentIdentifier memory emptyReplyTo;
+
+        vm.expectRevert(IComments.NotSmartWallet.selector);
+        vm.prank(collectorWithoutToken);
+        comments.comment({
+            commenter: collectorWithoutToken,
+            contractAddress: address(mock1155),
+            tokenId: tokenId1,
+            text: "test comment",
+            replyTo: emptyReplyTo,
+            commenterSmartWallet: smartWallet,
+            referrer: address(0)
+        });
+    }
+}

package/test/mocks/Mock1155.sol

@@ -8,6 +8,9 @@ contract Mock1155 is ERC1155, IZoraCreator1155 {
     /// @notice This user role allows for any action to be performed
     uint256 public constant PERMISSION_BIT_ADMIN = 2 ** 1;
 
+    /// @notice Global contract configuration
+    ContractConfig public config;
+
     mapping(uint256 => address) public admins;
 
     constructor() ERC1155("") {}
@@ -40,11 +43,19 @@ contract Mock1155 is ERC1155, IZoraCreator1155 {
         return super.supportsInterface(interfaceId);
     }
 
-    function mint(address to, uint256 id, uint256 amount, bytes memory data) external {
+    function mint(address to, uint256 id, uint256 amount, bytes memory data) external payable {
         if (!_tokenExists(id)) {
             revert("Token does not exist");
         }
 
         _mint(to, id, amount, data);
     }
+
+    function owner() external view returns (address) {
+        return config.owner;
+    }
+
+    function burn(address from, uint256 id, uint256 amount) external {
+        _safeTransferFrom(from, address(0), id, amount, "");
+    }
 }

package/test/mocks/Mock1155NoCreatorRewardRecipient.sol

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {ERC1155} from "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
+import {IZoraCreator1155} from "./MockIZoraCreator1155.sol";
+
+contract Mock1155NoCreatorRewardRecipient is ERC1155, IZoraCreator1155 {
+    /// @notice This user role allows for any action to be performed
+    uint256 public constant PERMISSION_BIT_ADMIN = 2 ** 1;
+
+    /// @notice Global contract configuration
+    ContractConfig public config;
+
+    mapping(uint256 => address) public admins;
+
+    constructor() ERC1155("") {}
+
+    function isAdminOrRole(address user, uint256 tokenId, uint256 role) external view returns (bool) {
+        if (admins[tokenId] == user && role == PERMISSION_BIT_ADMIN) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    function _tokenExists(uint256 tokenId) internal view returns (bool) {
+        return admins[tokenId] != address(0);
+    }
+
+    function createToken(uint256 tokenId, address creator) external {
+        admins[tokenId] = creator;
+    }
+
+    function supportsInterface(bytes4 interfaceId) public view override(ERC1155, IZoraCreator1155) returns (bool) {
+        return super.supportsInterface(interfaceId);
+    }
+
+    function mint(address to, uint256 id, uint256 amount, bytes memory data) external {
+        if (!_tokenExists(id)) {
+            revert("Token does not exist");
+        }
+
+        _mint(to, id, amount, data);
+    }
+
+    function _setFundsRecipient(address payable fundsRecipient) internal {
+        config.fundsRecipient = fundsRecipient;
+    }
+
+    function setFundsRecipient(address payable fundsRecipient) external {
+        _setFundsRecipient(fundsRecipient);
+    }
+
+    function owner() external view returns (address) {
+        return config.owner;
+    }
+
+    function _setOwner(address newOwner) internal {
+        config.owner = newOwner;
+    }
+
+    function setOwner(address newOwner) external {
+        _setOwner(newOwner);
+    }
+}

package/test/mocks/Mock1155NoOwner.sol

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {ERC1155} from "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
+import {IERC1155} from "@openzeppelin/contracts/interfaces/IERC1155.sol";
+import {IZoraCreator1155TypesV1} from "../../src/interfaces/IZoraCreator1155TypesV1.sol";
+
+// For testing without getCreatorRewardRecipient
+interface IZoraCreator1155 is IERC1155, IZoraCreator1155TypesV1 {
+    function isAdminOrRole(address user, uint256 tokenId, uint256 role) external view returns (bool);
+
+    function supportsInterface(bytes4 interfaceId) external view returns (bool);
+}
+
+contract Mock1155NoOwner is ERC1155, IZoraCreator1155 {
+    /// @notice This user role allows for any action to be performed
+    uint256 public constant PERMISSION_BIT_ADMIN = 2 ** 1;
+
+    /// @notice Global contract configuration
+    ContractConfig public config;
+
+    mapping(uint256 => address) public admins;
+
+    constructor() ERC1155("") {}
+
+    function isAdminOrRole(address user, uint256 tokenId, uint256 role) external view returns (bool) {
+        if (admins[tokenId] == user && role == PERMISSION_BIT_ADMIN) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    function _tokenExists(uint256 tokenId) internal view returns (bool) {
+        return admins[tokenId] != address(0);
+    }
+
+    function createToken(uint256 tokenId, address creator) external {
+        admins[tokenId] = creator;
+    }
+
+    function supportsInterface(bytes4 interfaceId) public view override(ERC1155, IZoraCreator1155) returns (bool) {
+        return super.supportsInterface(interfaceId);
+    }
+
+    function mint(address to, uint256 id, uint256 amount, bytes memory data) external {
+        if (!_tokenExists(id)) {
+            revert("Token does not exist");
+        }
+
+        _mint(to, id, amount, data);
+    }
+}