@bannynet/core-v6 0.0.2 → 0.0.4

package/test/regression/L57_BodyCategoryValidation.t.sol

@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+import "forge-std/Test.sol";
+import {JB721Tier} from "@bananapus/721-hook-v6/src/structs/JB721Tier.sol";
+import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
+
+import {Banny721TokenUriResolver} from "../../src/Banny721TokenUriResolver.sol";
+
+/// @notice Minimal mock hook.
+contract MockHook57 {
+    mapping(uint256 => address) public ownerOf;
+    address public immutable MOCK_STORE;
+    mapping(address => mapping(address => bool)) public isApprovedForAll;
+
+    constructor(address store) {
+        MOCK_STORE = store;
+    }
+
+    function STORE() external view returns (address) {
+        return MOCK_STORE;
+    }
+
+    function setOwner(uint256 tokenId, address owner) external {
+        ownerOf[tokenId] = owner;
+    }
+
+    function setApprovalForAll(address operator, bool approved) external {
+        isApprovedForAll[msg.sender][operator] = approved;
+    }
+
+    function safeTransferFrom(address from, address to, uint256 tokenId) external {
+        require(
+            msg.sender == ownerOf[tokenId] || msg.sender == from || isApprovedForAll[from][msg.sender],
+            "MockHook: not authorized"
+        );
+        ownerOf[tokenId] = to;
+        if (to.code.length > 0) {
+            bytes4 retval = IERC721Receiver(to).onERC721Received(msg.sender, from, tokenId, "");
+            require(retval == IERC721Receiver.onERC721Received.selector, "MockHook: receiver rejected");
+        }
+    }
+
+    function pricingContext() external pure returns (uint256, uint256, uint256) {
+        return (1, 18, 0);
+    }
+
+    function baseURI() external pure returns (string memory) {
+        return "ipfs://";
+    }
+}
+
+/// @notice Minimal mock store.
+contract MockStore57 {
+    mapping(address => mapping(uint256 => JB721Tier)) public tiers;
+
+    function setTier(address hook, uint256 tokenId, JB721Tier memory tier) external {
+        tiers[hook][tokenId] = tier;
+    }
+
+    function tierOfTokenId(address hook, uint256 tokenId, bool) external view returns (JB721Tier memory) {
+        return tiers[hook][tokenId];
+    }
+
+    function encodedIPFSUriOf(address, uint256) external pure returns (bytes32) {
+        return bytes32(0);
+    }
+}
+
+/// @notice Regression test: L-57 -- decorateBannyWith should reject non-body-category tokens as bannyBodyId.
+contract L57_BodyCategoryValidationTest is Test {
+    Banny721TokenUriResolver resolver;
+    MockHook57 hook;
+    MockStore57 store;
+
+    address deployer = makeAddr("deployer");
+    address alice = makeAddr("alice");
+
+    uint256 constant BODY_TOKEN = 4_000_000_001; // category 0 (body)
+    uint256 constant NECKLACE_TOKEN = 10_000_000_001; // category 3 (necklace)
+
+    function setUp() public {
+        store = new MockStore57();
+        hook = new MockHook57(address(store));
+
+        vm.prank(deployer);
+        resolver = new Banny721TokenUriResolver(
+            "<path/>", "<necklace/>", "<mouth/>", "<eyes/>", "<alieneyes/>", deployer, address(0)
+        );
+
+        // Set up body token (category 0).
+        _setupTier(BODY_TOKEN, 4, 0);
+        hook.setOwner(BODY_TOKEN, alice);
+
+        // Set up necklace token (category 3) -- NOT a body.
+        _setupTier(NECKLACE_TOKEN, 10, 3);
+        hook.setOwner(NECKLACE_TOKEN, alice);
+
+        vm.prank(alice);
+        hook.setApprovalForAll(address(resolver), true);
+    }
+
+    /// @notice Passing a non-body token as bannyBodyId should revert.
+    function test_decorateBannyWith_revertsIfNotBodyCategory() public {
+        uint256[] memory outfitIds = new uint256[](0);
+
+        vm.prank(alice);
+        vm.expectRevert(Banny721TokenUriResolver.Banny721TokenUriResolver_BannyBodyNotBodyCategory.selector);
+        resolver.decorateBannyWith(address(hook), NECKLACE_TOKEN, 0, outfitIds);
+    }
+
+    /// @notice Passing a valid body token should succeed.
+    function test_decorateBannyWith_succeedsWithBodyCategory() public {
+        uint256[] memory outfitIds = new uint256[](0);
+
+        vm.prank(alice);
+        resolver.decorateBannyWith(address(hook), BODY_TOKEN, 0, outfitIds);
+        // Should not revert.
+    }
+
+    function _setupTier(uint256 tokenId, uint32 tierId, uint24 category) internal {
+        JB721Tier memory tier = JB721Tier({
+            id: tierId,
+            price: 0.01 ether,
+            remainingSupply: 100,
+            initialSupply: 100,
+            votingUnits: 0,
+            reserveFrequency: 0,
+            reserveBeneficiary: address(0),
+            encodedIPFSUri: bytes32(0),
+            category: category,
+            discountPercent: 0,
+            allowOwnerMint: false,
+            transfersPausable: false,
+            cannotBeRemoved: false,
+            cannotIncreaseDiscountPercent: false,
+            splitPercent: 0,
+            resolvedUri: ""
+        });
+        store.setTier(address(hook), tokenId, tier);
+    }
+}

package/test/regression/L58_ArrayLengthValidation.t.sol

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+import "forge-std/Test.sol";
+import {JB721Tier} from "@bananapus/721-hook-v6/src/structs/JB721Tier.sol";
+
+import {Banny721TokenUriResolver} from "../../src/Banny721TokenUriResolver.sol";
+
+/// @notice Regression test: L-58 -- mismatched array lengths should revert.
+contract L58_ArrayLengthValidationTest is Test {
+    Banny721TokenUriResolver resolver;
+    address deployer = makeAddr("deployer");
+
+    function setUp() public {
+        vm.prank(deployer);
+        resolver = new Banny721TokenUriResolver(
+            "<path/>", "<necklace/>", "<mouth/>", "<eyes/>", "<alieneyes/>", deployer, address(0)
+        );
+    }
+
+    function test_setProductNames_revertsOnMismatchedLengths() public {
+        uint256[] memory upcs = new uint256[](2);
+        upcs[0] = 1;
+        upcs[1] = 2;
+
+        string[] memory names = new string[](1);
+        names[0] = "Only One";
+
+        vm.prank(deployer);
+        vm.expectRevert(Banny721TokenUriResolver.Banny721TokenUriResolver_ArrayLengthMismatch.selector);
+        resolver.setProductNames(upcs, names);
+    }
+
+    function test_setSvgContentsOf_revertsOnMismatchedLengths() public {
+        uint256[] memory upcs = new uint256[](2);
+        upcs[0] = 1;
+        upcs[1] = 2;
+
+        string[] memory contents = new string[](1);
+        contents[0] = "only one";
+
+        vm.expectRevert(Banny721TokenUriResolver.Banny721TokenUriResolver_ArrayLengthMismatch.selector);
+        resolver.setSvgContentsOf(upcs, contents);
+    }
+
+    function test_setSvgHashesOf_revertsOnMismatchedLengths() public {
+        uint256[] memory upcs = new uint256[](2);
+        upcs[0] = 1;
+        upcs[1] = 2;
+
+        bytes32[] memory hashes = new bytes32[](1);
+        hashes[0] = keccak256("test");
+
+        vm.prank(deployer);
+        vm.expectRevert(Banny721TokenUriResolver.Banny721TokenUriResolver_ArrayLengthMismatch.selector);
+        resolver.setSvgHashesOf(upcs, hashes);
+    }
+}

package/test/regression/L59_ClearMetadata.t.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+import "forge-std/Test.sol";
+
+import {Banny721TokenUriResolver} from "../../src/Banny721TokenUriResolver.sol";
+
+/// @notice Regression test: L-59 -- setMetadata should allow clearing fields to empty string.
+contract L59_ClearMetadataTest is Test {
+    Banny721TokenUriResolver resolver;
+    address deployer = makeAddr("deployer");
+
+    function setUp() public {
+        vm.prank(deployer);
+        resolver = new Banny721TokenUriResolver(
+            "<path/>", "<necklace/>", "<mouth/>", "<eyes/>", "<alieneyes/>", deployer, address(0)
+        );
+    }
+
+    function test_setMetadata_canClearToEmpty() public {
+        // First, set some values.
+        vm.prank(deployer);
+        resolver.setMetadata("Initial desc", "https://initial.url", "https://initial.base/");
+
+        assertEq(resolver.svgDescription(), "Initial desc");
+        assertEq(resolver.svgExternalUrl(), "https://initial.url");
+        assertEq(resolver.svgBaseUri(), "https://initial.base/");
+
+        // Now clear all fields by passing empty strings.
+        vm.prank(deployer);
+        resolver.setMetadata("", "", "");
+
+        // Fields should now be empty (cleared), not still holding old values.
+        assertEq(resolver.svgDescription(), "", "description should be cleared");
+        assertEq(resolver.svgExternalUrl(), "", "url should be cleared");
+        assertEq(resolver.svgBaseUri(), "", "baseUri should be cleared");
+    }
+
+    function test_setMetadata_canClearIndividualField() public {
+        // Set all fields.
+        vm.prank(deployer);
+        resolver.setMetadata("desc", "https://url", "https://base/");
+
+        // Clear only description, keep others.
+        vm.prank(deployer);
+        resolver.setMetadata("", "https://url", "https://base/");
+
+        assertEq(resolver.svgDescription(), "", "description should be cleared");
+        assertEq(resolver.svgExternalUrl(), "https://url", "url should be unchanged");
+        assertEq(resolver.svgBaseUri(), "https://base/", "baseUri should be unchanged");
+    }
+}

package/test/regression/L62_BurnedTokenCheck.t.sol

@@ -0,0 +1,181 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+import "forge-std/Test.sol";
+import {JB721Tier} from "@bananapus/721-hook-v6/src/structs/JB721Tier.sol";
+import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
+
+import {Banny721TokenUriResolver} from "../../src/Banny721TokenUriResolver.sol";
+
+/// @notice Mock hook that supports burning (setting owner to address(0) so ownerOf reverts).
+contract MockHook62 {
+    mapping(uint256 => address) public owners;
+    address public immutable MOCK_STORE;
+    mapping(address => mapping(address => bool)) public isApprovedForAll;
+
+    constructor(address store) {
+        MOCK_STORE = store;
+    }
+
+    function STORE() external view returns (address) {
+        return MOCK_STORE;
+    }
+
+    function setOwner(uint256 tokenId, address owner) external {
+        owners[tokenId] = owner;
+    }
+
+    function ownerOf(uint256 tokenId) external view returns (address) {
+        address owner = owners[tokenId];
+        require(owner != address(0), "ERC721: token does not exist");
+        return owner;
+    }
+
+    function burn(uint256 tokenId) external {
+        owners[tokenId] = address(0);
+    }
+
+    function setApprovalForAll(address operator, bool approved) external {
+        isApprovedForAll[msg.sender][operator] = approved;
+    }
+
+    function safeTransferFrom(address from, address to, uint256 tokenId) external {
+        address owner = owners[tokenId];
+        require(owner != address(0), "ERC721: token does not exist");
+        require(
+            msg.sender == owner || msg.sender == from || isApprovedForAll[from][msg.sender], "MockHook: not authorized"
+        );
+        owners[tokenId] = to;
+        if (to.code.length > 0) {
+            bytes4 retval = IERC721Receiver(to).onERC721Received(msg.sender, from, tokenId, "");
+            require(retval == IERC721Receiver.onERC721Received.selector, "MockHook: receiver rejected");
+        }
+    }
+
+    function pricingContext() external pure returns (uint256, uint256, uint256) {
+        return (1, 18, 0);
+    }
+
+    function baseURI() external pure returns (string memory) {
+        return "ipfs://";
+    }
+}
+
+/// @notice Minimal mock store.
+contract MockStore62 {
+    mapping(address => mapping(uint256 => JB721Tier)) public tiers;
+
+    function setTier(address hook, uint256 tokenId, JB721Tier memory tier) external {
+        tiers[hook][tokenId] = tier;
+    }
+
+    function tierOfTokenId(address hook, uint256 tokenId, bool) external view returns (JB721Tier memory) {
+        return tiers[hook][tokenId];
+    }
+
+    function encodedIPFSUriOf(address, uint256) external pure returns (bytes32) {
+        return bytes32(0);
+    }
+}
+
+/// @notice Regression test: L-62 -- burned equipped tokens should not lock the body.
+contract L62_BurnedTokenCheckTest is Test {
+    Banny721TokenUriResolver resolver;
+    MockHook62 hook;
+    MockStore62 store;
+
+    address deployer = makeAddr("deployer");
+    address alice = makeAddr("alice");
+
+    uint256 constant BODY_TOKEN = 4_000_000_001;
+    uint256 constant NECKLACE_TOKEN = 10_000_000_001;
+    uint256 constant EYES_TOKEN = 30_000_000_001;
+
+    function setUp() public {
+        store = new MockStore62();
+        hook = new MockHook62(address(store));
+
+        vm.prank(deployer);
+        resolver = new Banny721TokenUriResolver(
+            "<path/>", "<necklace/>", "<mouth/>", "<eyes/>", "<alieneyes/>", deployer, address(0)
+        );
+
+        _setupTier(BODY_TOKEN, 4, 0);
+        _setupTier(NECKLACE_TOKEN, 10, 3);
+        _setupTier(EYES_TOKEN, 30, 5);
+
+        hook.setOwner(BODY_TOKEN, alice);
+        hook.setOwner(NECKLACE_TOKEN, alice);
+        hook.setOwner(EYES_TOKEN, alice);
+
+        vm.prank(alice);
+        hook.setApprovalForAll(address(resolver), true);
+    }
+
+    /// @notice If an equipped outfit is burned, the body should still be able to change outfits.
+    function test_decorateBannyWith_succeedsAfterEquippedOutfitBurned() public {
+        // Equip a necklace.
+        uint256[] memory outfitIds = new uint256[](1);
+        outfitIds[0] = NECKLACE_TOKEN;
+
+        vm.prank(alice);
+        resolver.decorateBannyWith(address(hook), BODY_TOKEN, 0, outfitIds);
+
+        // Verify necklace is equipped.
+        assertEq(resolver.wearerOf(address(hook), NECKLACE_TOKEN), BODY_TOKEN);
+
+        // Burn the necklace (simulate external burn while it's equipped).
+        hook.burn(NECKLACE_TOKEN);
+
+        // Now try to change outfits -- equip eyes instead. This should NOT revert.
+        uint256[] memory newOutfitIds = new uint256[](1);
+        newOutfitIds[0] = EYES_TOKEN;
+
+        vm.prank(alice);
+        resolver.decorateBannyWith(address(hook), BODY_TOKEN, 0, newOutfitIds);
+
+        // Verify new outfit is equipped.
+        assertEq(resolver.wearerOf(address(hook), EYES_TOKEN), BODY_TOKEN);
+    }
+
+    /// @notice If an equipped outfit is burned, the body should be able to clear all outfits.
+    function test_decorateBannyWith_canClearOutfitsAfterBurn() public {
+        // Equip a necklace.
+        uint256[] memory outfitIds = new uint256[](1);
+        outfitIds[0] = NECKLACE_TOKEN;
+
+        vm.prank(alice);
+        resolver.decorateBannyWith(address(hook), BODY_TOKEN, 0, outfitIds);
+
+        // Burn the necklace.
+        hook.burn(NECKLACE_TOKEN);
+
+        // Clear all outfits. This should NOT revert.
+        uint256[] memory emptyOutfits = new uint256[](0);
+
+        vm.prank(alice);
+        resolver.decorateBannyWith(address(hook), BODY_TOKEN, 0, emptyOutfits);
+    }
+
+    function _setupTier(uint256 tokenId, uint32 tierId, uint24 category) internal {
+        JB721Tier memory tier = JB721Tier({
+            id: tierId,
+            price: 0.01 ether,
+            remainingSupply: 100,
+            initialSupply: 100,
+            votingUnits: 0,
+            reserveFrequency: 0,
+            reserveBeneficiary: address(0),
+            encodedIPFSUri: bytes32(0),
+            category: category,
+            discountPercent: 0,
+            allowOwnerMint: false,
+            transfersPausable: false,
+            cannotBeRemoved: false,
+            cannotIncreaseDiscountPercent: false,
+            splitPercent: 0,
+            resolvedUri: ""
+        });
+        store.setTier(address(hook), tokenId, tier);
+    }
+}