@bananapus/721-hook-v6 0.0.41 → 0.0.43

package/test/unit/JB721CheckpointsDeployer_AccessControl.t.sol

@@ -1,116 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.28;
-
-import {Test} from "forge-std/Test.sol";
-import {JB721CheckpointsDeployer} from "../../src/JB721CheckpointsDeployer.sol";
-import {IJB721CheckpointsDeployer} from "../../src/interfaces/IJB721CheckpointsDeployer.sol";
-import {IJB721Checkpoints} from "../../src/interfaces/IJB721Checkpoints.sol";
-import {IJB721TiersHookStore} from "../../src/interfaces/IJB721TiersHookStore.sol";
-
-/// @notice H-1 audit fix: access control tests for JB721CheckpointsDeployer.deploy().
-/// @dev The deployer must only allow the hook address itself (msg.sender == hook) to call deploy().
-contract Test_JB721CheckpointsDeployer_AccessControl is Test {
-    JB721CheckpointsDeployer deployer;
-    address mockStore;
-
-    function setUp() public {
-        deployer = new JB721CheckpointsDeployer();
-        mockStore = makeAddr("mockStore");
-        vm.etch(mockStore, new bytes(0x69));
-    }
-
-    // ═══════════════════════════════════════════════════════════
-    // Test 1: Calling deploy() from the hook address succeeds
-    // ═══════════════════════════════════════════════════════════
-
-    /// @notice deploy() succeeds when msg.sender == hook parameter.
-    function test_deploy_succeedsWhenCallerIsHook() public {
-        address hookAddr = makeAddr("hook");
-
-        // Call deploy from the hook address, passing itself as the hook parameter.
-        vm.prank(hookAddr);
-        IJB721Checkpoints module = deployer.deploy(hookAddr, IJB721TiersHookStore(mockStore));
-
-        // Verify the module was deployed (non-zero address).
-        assertTrue(address(module) != address(0), "Module should be deployed");
-    }
-
-    // ═══════════════════════════════════════════════════════════
-    // Test 2: Calling deploy() from any other address reverts
-    // ═══════════════════════════════════════════════════════════
-
-    /// @notice deploy() reverts with Unauthorized when msg.sender != hook.
-    function test_deploy_revertsWhenCallerIsNotHook() public {
-        address hookAddr = makeAddr("hook");
-        address attacker = makeAddr("attacker");
-
-        vm.prank(attacker);
-        vm.expectRevert(IJB721CheckpointsDeployer.JB721CheckpointsDeployer_Unauthorized.selector);
-        deployer.deploy(hookAddr, IJB721TiersHookStore(mockStore));
-    }
-
-    /// @notice deploy() reverts when caller passes their own address as hook but is not the actual hook.
-    function test_deploy_revertsWhenCallerPassesSelfButIsNotHook() public {
-        address attacker = makeAddr("attacker");
-        address realHook = makeAddr("realHook");
-
-        // Attacker tries to pass realHook as the hook parameter but calls from their own address.
-        vm.prank(attacker);
-        vm.expectRevert(IJB721CheckpointsDeployer.JB721CheckpointsDeployer_Unauthorized.selector);
-        deployer.deploy(realHook, IJB721TiersHookStore(mockStore));
-    }
-
-    // ═══════════════════════════════════════════════════════════
-    // Test 3: Front-running scenario
-    // ═══════════════════════════════════════════════════════════
-
-    /// @notice An attacker cannot front-run the hook by calling deploy() with the hook's address.
-    ///         Since msg.sender must equal hook, the attacker's tx reverts.
-    function test_deploy_frontRunningRevertsForAttacker() public {
-        address hookAddr = makeAddr("hook");
-        address frontRunner = makeAddr("frontRunner");
-
-        // Front-runner attempts to call deploy with the hook's address before the hook does.
-        vm.prank(frontRunner);
-        vm.expectRevert(IJB721CheckpointsDeployer.JB721CheckpointsDeployer_Unauthorized.selector);
-        deployer.deploy(hookAddr, IJB721TiersHookStore(mockStore));
-
-        // The legitimate hook can still deploy successfully after the failed front-run attempt.
-        vm.prank(hookAddr);
-        IJB721Checkpoints module = deployer.deploy(hookAddr, IJB721TiersHookStore(mockStore));
-        assertTrue(address(module) != address(0), "Hook should deploy successfully after failed front-run");
-    }
-
-    /// @notice An attacker who calls deploy(attacker, store) from their own address gets a clone
-    ///         for themselves, but this does NOT affect the real hook's future deployment.
-    function test_deploy_attackerDeploysOwnClone_doesNotAffectRealHook() public {
-        address hookAddr = makeAddr("hook");
-        address attacker = makeAddr("attacker");
-
-        // Attacker deploys their own clone (msg.sender == attacker == hook param).
-        // This succeeds because msg.sender == hook parameter.
-        vm.prank(attacker);
-        IJB721Checkpoints attackerModule = deployer.deploy(attacker, IJB721TiersHookStore(mockStore));
-        assertTrue(address(attackerModule) != address(0), "Attacker can deploy their own clone");
-
-        // The real hook can still deploy its own clone (different salt = different CREATE2 address).
-        vm.prank(hookAddr);
-        IJB721Checkpoints hookModule = deployer.deploy(hookAddr, IJB721TiersHookStore(mockStore));
-        assertTrue(address(hookModule) != address(0), "Real hook can still deploy its own clone");
-
-        // The two clones are at different addresses.
-        assertTrue(
-            address(attackerModule) != address(hookModule),
-            "Attacker clone and hook clone should be different addresses"
-        );
-    }
-
-    /// @notice Fuzz: any random caller that is not the hook reverts.
-    function testFuzz_deploy_revertsForArbitraryCaller(address caller, address hookAddr) public {
-        vm.assume(caller != hookAddr);
-
-        vm.prank(caller);
-        vm.expectRevert(IJB721CheckpointsDeployer.JB721CheckpointsDeployer_Unauthorized.selector);
-        deployer.deploy(hookAddr, IJB721TiersHookStore(mockStore));
-    }
-}

package/test/unit/JB721TiersRulesetMetadataResolver.t.sol

@@ -1,144 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.28;
-
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "forge-std/Test.sol";
-
-import {JB721TiersRulesetMetadataResolver} from "../../src/libraries/JB721TiersRulesetMetadataResolver.sol";
-import {JB721TiersRulesetMetadata} from "../../src/structs/JB721TiersRulesetMetadata.sol";
-
-/// @notice Unit + fuzz tests for `JB721TiersRulesetMetadataResolver`.
-contract TestJB721TiersRulesetMetadataResolver is Test {
-    //*********************************************************************//
-    // --- pack: individual flags ---------------------------------------- //
-    //*********************************************************************//
-
-    function test_pack_allFalse() public {
-        JB721TiersRulesetMetadata memory meta =
-            JB721TiersRulesetMetadata({pauseTransfers: false, pauseMintPendingReserves: false});
-        uint256 packed = JB721TiersRulesetMetadataResolver.pack721TiersRulesetMetadata(meta);
-        assertEq(packed, 0, "both false should pack to 0");
-    }
-
-    function test_pack_pauseTransfersOnly() public {
-        JB721TiersRulesetMetadata memory meta =
-            JB721TiersRulesetMetadata({pauseTransfers: true, pauseMintPendingReserves: false});
-        uint256 packed = JB721TiersRulesetMetadataResolver.pack721TiersRulesetMetadata(meta);
-        assertEq(packed, 1, "pauseTransfers only should pack to 1");
-    }
-
-    function test_pack_pauseMintPendingReservesOnly() public {
-        JB721TiersRulesetMetadata memory meta =
-            JB721TiersRulesetMetadata({pauseTransfers: false, pauseMintPendingReserves: true});
-        uint256 packed = JB721TiersRulesetMetadataResolver.pack721TiersRulesetMetadata(meta);
-        assertEq(packed, 2, "pauseMintPendingReserves only should pack to 2");
-    }
-
-    function test_pack_bothTrue() public {
-        JB721TiersRulesetMetadata memory meta =
-            JB721TiersRulesetMetadata({pauseTransfers: true, pauseMintPendingReserves: true});
-        uint256 packed = JB721TiersRulesetMetadataResolver.pack721TiersRulesetMetadata(meta);
-        assertEq(packed, 3, "both true should pack to 3");
-    }
-
-    //*********************************************************************//
-    // --- transfersPaused / mintPendingReservesPaused -------------------- //
-    //*********************************************************************//
-
-    function test_transfersPaused() public {
-        assertFalse(JB721TiersRulesetMetadataResolver.transfersPaused(0));
-        assertTrue(JB721TiersRulesetMetadataResolver.transfersPaused(1));
-        assertFalse(JB721TiersRulesetMetadataResolver.transfersPaused(2));
-        assertTrue(JB721TiersRulesetMetadataResolver.transfersPaused(3));
-    }
-
-    function test_mintPendingReservesPaused() public {
-        assertFalse(JB721TiersRulesetMetadataResolver.mintPendingReservesPaused(0));
-        assertFalse(JB721TiersRulesetMetadataResolver.mintPendingReservesPaused(1));
-        assertTrue(JB721TiersRulesetMetadataResolver.mintPendingReservesPaused(2));
-        assertTrue(JB721TiersRulesetMetadataResolver.mintPendingReservesPaused(3));
-    }
-
-    //*********************************************************************//
-    // --- expandMetadata ------------------------------------------------ //
-    //*********************************************************************//
-
-    function test_expandMetadata_zero() public {
-        JB721TiersRulesetMetadata memory meta = JB721TiersRulesetMetadataResolver.expandMetadata(0);
-        assertFalse(meta.pauseTransfers);
-        assertFalse(meta.pauseMintPendingReserves);
-    }
-
-    function test_expandMetadata_one() public {
-        JB721TiersRulesetMetadata memory meta = JB721TiersRulesetMetadataResolver.expandMetadata(1);
-        assertTrue(meta.pauseTransfers);
-        assertFalse(meta.pauseMintPendingReserves);
-    }
-
-    function test_expandMetadata_two() public {
-        JB721TiersRulesetMetadata memory meta = JB721TiersRulesetMetadataResolver.expandMetadata(2);
-        assertFalse(meta.pauseTransfers);
-        assertTrue(meta.pauseMintPendingReserves);
-    }
-
-    function test_expandMetadata_three() public {
-        JB721TiersRulesetMetadata memory meta = JB721TiersRulesetMetadataResolver.expandMetadata(3);
-        assertTrue(meta.pauseTransfers);
-        assertTrue(meta.pauseMintPendingReserves);
-    }
-
-    //*********************************************************************//
-    // --- Round-Trip ----------------------------------------------------- //
-    //*********************************************************************//
-
-    function test_packExpandRoundTrip_allCombinations() public {
-        for (uint256 i; i < 4; i++) {
-            bool transfers = (i & 1) == 1;
-            bool reserves = (i & 2) == 2;
-
-            JB721TiersRulesetMetadata memory meta =
-                JB721TiersRulesetMetadata({pauseTransfers: transfers, pauseMintPendingReserves: reserves});
-
-            uint256 packed = JB721TiersRulesetMetadataResolver.pack721TiersRulesetMetadata(meta);
-            // forge-lint: disable-next-line(unsafe-typecast)
-            JB721TiersRulesetMetadata memory expanded = JB721TiersRulesetMetadataResolver.expandMetadata(uint16(packed));
-
-            assertEq(expanded.pauseTransfers, transfers, "transfers round-trip");
-            assertEq(expanded.pauseMintPendingReserves, reserves, "reserves round-trip");
-        }
-    }
-
-    //*********************************************************************//
-    // --- Fuzz ---------------------------------------------------------- //
-    //*********************************************************************//
-
-    function testFuzz_packExpandRoundTrip(bool pauseTransfers, bool pauseMintPendingReserves) public {
-        JB721TiersRulesetMetadata memory meta = JB721TiersRulesetMetadata({
-            pauseTransfers: pauseTransfers, pauseMintPendingReserves: pauseMintPendingReserves
-        });
-
-        uint256 packed = JB721TiersRulesetMetadataResolver.pack721TiersRulesetMetadata(meta);
-        // forge-lint: disable-next-line(unsafe-typecast)
-        JB721TiersRulesetMetadata memory expanded = JB721TiersRulesetMetadataResolver.expandMetadata(uint16(packed));
-
-        assertEq(expanded.pauseTransfers, pauseTransfers, "fuzz transfers round-trip");
-        assertEq(expanded.pauseMintPendingReserves, pauseMintPendingReserves, "fuzz reserves round-trip");
-    }
-
-    function testFuzz_transfersPaused_bitIsolation(uint256 data) public {
-        bool result = JB721TiersRulesetMetadataResolver.transfersPaused(data);
-        assertEq(result, (data & 1) == 1, "transfersPaused should check bit 0");
-    }
-
-    function testFuzz_mintPendingReservesPaused_bitIsolation(uint256 data) public {
-        bool result = JB721TiersRulesetMetadataResolver.mintPendingReservesPaused(data);
-        assertEq(result, ((data >> 1) & 1) == 1, "mintPendingReservesPaused should check bit 1");
-    }
-
-    function testFuzz_pack_onlyUsesLow2Bits(bool a, bool b) public {
-        JB721TiersRulesetMetadata memory meta =
-            JB721TiersRulesetMetadata({pauseTransfers: a, pauseMintPendingReserves: b});
-        uint256 packed = JB721TiersRulesetMetadataResolver.pack721TiersRulesetMetadata(meta);
-        assertEq(packed & ~uint256(3), 0, "packed value should only use bits 0 and 1");
-    }
-}

package/test/unit/JBBitmap.t.sol

@@ -1,170 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.28;
-
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "forge-std/Test.sol";
-
-import {JBBitmap} from "../../src/libraries/JBBitmap.sol";
-import {JBBitmapWord} from "../../src/structs/JBBitmapWord.sol";
-
-/// @notice Unit + fuzz tests for `JBBitmap`.
-contract TestJBBitmap is Test {
-    using JBBitmap for mapping(uint256 => uint256);
-    using JBBitmap for JBBitmapWord;
-
-    mapping(uint256 => uint256) internal bitmap;
-
-    //*********************************************************************//
-    // --- readId -------------------------------------------------------- //
-    //*********************************************************************//
-
-    function test_readId_initiallyZero() public {
-        JBBitmapWord memory word = bitmap.readId(0);
-        assertEq(word.currentWord, 0, "initial word should be 0");
-        assertEq(word.currentDepth, 0, "depth for index 0 should be 0");
-    }
-
-    function test_readId_depthCalculation() public {
-        // Index 255 is in depth 0, index 256 is in depth 1.
-        JBBitmapWord memory word0 = bitmap.readId(255);
-        assertEq(word0.currentDepth, 0, "index 255 should be depth 0");
-
-        JBBitmapWord memory word1 = bitmap.readId(256);
-        assertEq(word1.currentDepth, 1, "index 256 should be depth 1");
-
-        JBBitmapWord memory word2 = bitmap.readId(512);
-        assertEq(word2.currentDepth, 2, "index 512 should be depth 2");
-    }
-
-    //*********************************************************************//
-    // --- removeTier / isTierIdRemoved ---------------------------------- //
-    //*********************************************************************//
-
-    function test_removeTier_setsbit() public {
-        assertFalse(bitmap.isTierIdRemoved(5), "should not be removed initially");
-
-        bitmap.removeTier(5);
-
-        assertTrue(bitmap.isTierIdRemoved(5), "should be removed after removeTier");
-    }
-
-    function test_removeTier_doesNotAffectOtherBits() public {
-        bitmap.removeTier(5);
-
-        assertFalse(bitmap.isTierIdRemoved(4), "adjacent bit should not be affected");
-        assertFalse(bitmap.isTierIdRemoved(6), "adjacent bit should not be affected");
-        assertFalse(bitmap.isTierIdRemoved(0), "index 0 should not be affected");
-    }
-
-    function test_removeTier_multipleBitsInSameWord() public {
-        bitmap.removeTier(0);
-        bitmap.removeTier(1);
-        bitmap.removeTier(255);
-
-        assertTrue(bitmap.isTierIdRemoved(0));
-        assertTrue(bitmap.isTierIdRemoved(1));
-        assertTrue(bitmap.isTierIdRemoved(255));
-        assertFalse(bitmap.isTierIdRemoved(2));
-    }
-
-    function test_removeTier_acrossWords() public {
-        bitmap.removeTier(0); // depth 0
-        bitmap.removeTier(256); // depth 1
-        bitmap.removeTier(512); // depth 2
-
-        assertTrue(bitmap.isTierIdRemoved(0));
-        assertTrue(bitmap.isTierIdRemoved(256));
-        assertTrue(bitmap.isTierIdRemoved(512));
-
-        assertFalse(bitmap.isTierIdRemoved(1));
-        assertFalse(bitmap.isTierIdRemoved(257));
-        assertFalse(bitmap.isTierIdRemoved(513));
-    }
-
-    function test_removeTier_idempotent() public {
-        bitmap.removeTier(10);
-        bitmap.removeTier(10); // Remove again.
-        assertTrue(bitmap.isTierIdRemoved(10), "should still be removed");
-    }
-
-    //*********************************************************************//
-    // --- isTierIdRemoved (memory struct variant) ----------------------- //
-    //*********************************************************************//
-
-    function test_isTierIdRemoved_memoryStruct() public {
-        bitmap.removeTier(3);
-
-        JBBitmapWord memory word = bitmap.readId(3);
-        assertTrue(word.isTierIdRemoved(3), "memory struct should read removed bit");
-        assertFalse(word.isTierIdRemoved(4), "memory struct should read non-removed bit");
-    }
-
-    function test_isTierIdRemoved_wrongDepthReturnsWrong() public {
-        bitmap.removeTier(3); // depth 0
-
-        // Read a word from depth 1 — should not see index 3's removal.
-        JBBitmapWord memory word = bitmap.readId(256);
-        assertFalse(word.isTierIdRemoved(3), "wrong depth should not see bit");
-    }
-
-    //*********************************************************************//
-    // --- refreshBitmapNeeded ------------------------------------------- //
-    //*********************************************************************//
-
-    function test_refreshBitmapNeeded_sameDepth() public {
-        JBBitmapWord memory word = bitmap.readId(0);
-        assertFalse(word.refreshBitmapNeeded(100), "same depth should not need refresh");
-        assertFalse(word.refreshBitmapNeeded(255), "still depth 0, no refresh needed");
-    }
-
-    function test_refreshBitmapNeeded_differentDepth() public {
-        JBBitmapWord memory word = bitmap.readId(0);
-        assertTrue(word.refreshBitmapNeeded(256), "depth 1 should need refresh from depth 0");
-        assertTrue(word.refreshBitmapNeeded(512), "depth 2 should need refresh from depth 0");
-    }
-
-    //*********************************************************************//
-    // --- Fuzz Tests ---------------------------------------------------- //
-    //*********************************************************************//
-
-    function testFuzz_removeTier_roundTrip(uint16 index) public {
-        assertFalse(bitmap.isTierIdRemoved(index), "should start unremoved");
-
-        bitmap.removeTier(index);
-
-        assertTrue(bitmap.isTierIdRemoved(index), "should be removed after removeTier");
-    }
-
-    function testFuzz_removeTier_isolatedBit(uint16 indexA, uint16 indexB) public {
-        vm.assume(indexA != indexB);
-
-        bitmap.removeTier(indexA);
-
-        assertTrue(bitmap.isTierIdRemoved(indexA), "A should be removed");
-        assertFalse(bitmap.isTierIdRemoved(indexB), "B should not be removed");
-    }
-
-    function testFuzz_readId_depthMatchesIndex(uint16 index) public {
-        JBBitmapWord memory word = bitmap.readId(index);
-        assertEq(word.currentDepth, uint256(index) >> 8, "depth should be index / 256");
-    }
-
-    function testFuzz_refreshBitmapNeeded_consistency(uint16 indexA, uint16 indexB) public {
-        JBBitmapWord memory word = bitmap.readId(indexA);
-        bool needed = word.refreshBitmapNeeded(indexB);
-        // Refresh is needed iff depths differ.
-        assertEq(needed, (uint256(indexA) >> 8) != (uint256(indexB) >> 8), "refresh iff different depth");
-    }
-
-    function testFuzz_removeTier_multipleBits(uint8 a, uint8 b, uint8 c) public {
-        vm.assume(a != b && b != c && a != c);
-
-        bitmap.removeTier(a);
-        bitmap.removeTier(b);
-        bitmap.removeTier(c);
-
-        assertTrue(bitmap.isTierIdRemoved(a));
-        assertTrue(bitmap.isTierIdRemoved(b));
-        assertTrue(bitmap.isTierIdRemoved(c));
-    }
-}

package/test/unit/JBIpfsDecoder.t.sol

@@ -1,136 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.28;
-
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "forge-std/Test.sol";
-
-import {JBIpfsDecoder} from "../../src/libraries/JBIpfsDecoder.sol";
-
-/// @notice Unit tests for `JBIpfsDecoder`.
-contract TestJBIpfsDecoder is Test {
-    /// @notice Known IPFS CID v0 hash for testing.
-    /// @dev Obtained by hashing a known payload: the CID for the hex 0x1220... prefix + this hash should decode to a
-    /// valid base58 string starting with "Qm".
-    bytes32 constant TEST_HASH = 0x7465737468617368000000000000000000000000000000000000000000000000;
-
-    //*********************************************************************//
-    // --- decode: basic output ------------------------------------------ //
-    //*********************************************************************//
-
-    function test_decode_prependsBaseUri() public {
-        string memory result = JBIpfsDecoder.decode("ipfs://", TEST_HASH);
-        // Result must start with the base URI.
-        bytes memory resultBytes = bytes(result);
-        bytes memory prefix = bytes("ipfs://");
-        for (uint256 i; i < prefix.length; i++) {
-            assertEq(resultBytes[i], prefix[i], "prefix mismatch");
-        }
-    }
-
-    function test_decode_emptyBaseUri() public {
-        string memory result = JBIpfsDecoder.decode("", TEST_HASH);
-        // Should still produce a non-empty base58 hash.
-        assertTrue(bytes(result).length > 0, "should produce output with empty base URI");
-    }
-
-    function test_decode_outputStartsWithQm() public {
-        // All CIDv0 hashes start with "Qm" because the 0x1220 prefix encodes to "Qm" in base58.
-        string memory result = JBIpfsDecoder.decode("", TEST_HASH);
-        bytes memory resultBytes = bytes(result);
-        // forge-lint: disable-next-line(unsafe-typecast)
-        assertEq(resultBytes[0], bytes1("Q"), "first char should be Q");
-        // forge-lint: disable-next-line(unsafe-typecast)
-        assertEq(resultBytes[1], bytes1("m"), "second char should be m");
-    }
-
-    function test_decode_outputLength() public {
-        // CIDv0 hashes are always 46 characters in base58.
-        string memory result = JBIpfsDecoder.decode("", TEST_HASH);
-        assertEq(bytes(result).length, 46, "CIDv0 base58 hash should be 46 characters");
-    }
-
-    //*********************************************************************//
-    // --- decode: determinism ------------------------------------------- //
-    //*********************************************************************//
-
-    function test_decode_deterministic() public {
-        string memory a = JBIpfsDecoder.decode("ipfs://", TEST_HASH);
-        string memory b = JBIpfsDecoder.decode("ipfs://", TEST_HASH);
-        assertEq(keccak256(bytes(a)), keccak256(bytes(b)), "same input should produce same output");
-    }
-
-    function test_decode_differentHashesDifferentOutput() public {
-        bytes32 hashA = bytes32(uint256(1));
-        bytes32 hashB = bytes32(uint256(2));
-        string memory a = JBIpfsDecoder.decode("", hashA);
-        string memory b = JBIpfsDecoder.decode("", hashB);
-        assertTrue(keccak256(bytes(a)) != keccak256(bytes(b)), "different hashes should produce different output");
-    }
-
-    //*********************************************************************//
-    // --- decode: base58 alphabet --------------------------------------- //
-    //*********************************************************************//
-
-    function test_decode_onlyBase58Chars() public {
-        string memory result = JBIpfsDecoder.decode("", TEST_HASH);
-        bytes memory resultBytes = bytes(result);
-        bytes memory alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-
-        for (uint256 i; i < resultBytes.length; i++) {
-            bool found;
-            for (uint256 j; j < alphabet.length; j++) {
-                if (resultBytes[i] == alphabet[j]) {
-                    found = true;
-                    break;
-                }
-            }
-            assertTrue(found, "output should only contain base58 characters");
-        }
-    }
-
-    //*********************************************************************//
-    // --- decode: fuzz -------------------------------------------------- //
-    //*********************************************************************//
-
-    function testFuzz_decode_alwaysProduces46Chars(bytes32 hash) public {
-        string memory result = JBIpfsDecoder.decode("", hash);
-        assertEq(bytes(result).length, 46, "any hash should produce 46-char CIDv0");
-    }
-
-    function testFuzz_decode_alwaysStartsWithQm(bytes32 hash) public {
-        string memory result = JBIpfsDecoder.decode("", hash);
-        bytes memory resultBytes = bytes(result);
-        // forge-lint: disable-next-line(unsafe-typecast)
-        assertEq(resultBytes[0], bytes1("Q"), "first char should be Q");
-        // forge-lint: disable-next-line(unsafe-typecast)
-        assertEq(resultBytes[1], bytes1("m"), "second char should be m");
-    }
-
-    function testFuzz_decode_prependsBaseUri(bytes32 hash, uint8 baseLen) public {
-        // Create a base URI of varying length (0-255 chars).
-        bytes memory base = new bytes(baseLen);
-        for (uint256 i; i < baseLen; i++) {
-            base[i] = "x";
-        }
-        string memory baseUri = string(base);
-        string memory result = JBIpfsDecoder.decode(baseUri, hash);
-        assertEq(bytes(result).length, uint256(baseLen) + 46, "output length = base + 46");
-    }
-
-    function testFuzz_decode_onlyBase58Chars(bytes32 hash) public {
-        string memory result = JBIpfsDecoder.decode("", hash);
-        bytes memory resultBytes = bytes(result);
-        bytes memory alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-
-        for (uint256 i; i < resultBytes.length; i++) {
-            bool found;
-            for (uint256 j; j < alphabet.length; j++) {
-                if (resultBytes[i] == alphabet[j]) {
-                    found = true;
-                    break;
-                }
-            }
-            assertTrue(found, "all chars should be in base58 alphabet");
-        }
-    }
-}