@bananapus/721-hook-v6 0.0.41 → 0.0.43

package/test/Fork.t.sol

@@ -1,2346 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.28;
-
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "forge-std/Test.sol";
-
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "@bananapus/core-v6/src/JBController.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "@bananapus/core-v6/src/JBDirectory.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "@bananapus/core-v6/src/JBMultiTerminal.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "@bananapus/core-v6/src/JBFundAccessLimits.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "@bananapus/core-v6/src/JBFeelessAddresses.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "@bananapus/core-v6/src/JBTerminalStore.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "@bananapus/core-v6/src/JBRulesets.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "@bananapus/core-v6/src/JBPermissions.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "@bananapus/core-v6/src/JBPrices.sol";
-import {JBProjects} from "@bananapus/core-v6/src/JBProjects.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "@bananapus/core-v6/src/JBSplits.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "@bananapus/core-v6/src/JBERC20.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "@bananapus/core-v6/src/JBTokens.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "@bananapus/core-v6/src/libraries/JBConstants.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "@bananapus/core-v6/src/libraries/JBRulesetMetadataResolver.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "@bananapus/core-v6/src/structs/JBAccountingContext.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "@bananapus/core-v6/src/structs/JBTerminalConfig.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "@bananapus/core-v6/src/structs/JBSplit.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "@bananapus/core-v6/src/structs/JBSplitGroup.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "@bananapus/core-v6/src/structs/JBFundAccessLimitGroup.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "@bananapus/core-v6/src/interfaces/IJBRulesetApprovalHook.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "@bananapus/core-v6/src/interfaces/IJBTerminal.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "@bananapus/permission-ids-v6/src/JBPermissionIds.sol";
-import {MetadataResolverHelper} from "@bananapus/core-v6/test/helpers/MetadataResolverHelper.sol";
-// forge-lint: disable-next-line(unused-import)
-import {mulDiv} from "@prb/math/src/Common.sol";
-
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "@bananapus/address-registry-v6/src/JBAddressRegistry.sol";
-
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "../src/JB721TiersHook.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "../src/JB721TiersHookDeployer.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "../src/JB721TiersHookProjectDeployer.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "../src/JB721TiersHookStore.sol";
-import {JB721CheckpointsDeployer} from "../src/JB721CheckpointsDeployer.sol";
-import {IJB721CheckpointsDeployer} from "../src/interfaces/IJB721CheckpointsDeployer.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "../src/interfaces/IJB721TiersHook.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "../src/structs/JBDeploy721TiersHookConfig.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "../src/structs/JBLaunchProjectConfig.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "../src/structs/JBPayDataHookRulesetConfig.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "../src/structs/JBPayDataHookRulesetMetadata.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "../src/structs/JB721TiersRulesetMetadata.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "../src/libraries/JB721TiersRulesetMetadataResolver.sol";
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "../src/libraries/JB721Constants.sol";
-import {JB721TierConfigFlags} from "../src/structs/JB721TierConfigFlags.sol";
-
-/// @title Fork_721Hook_Test
-/// @notice Comprehensive fork tests for JB721TiersHook: lifecycle, features, flags, and adversarial conditions.
-/// @dev Run with: RPC_ETHEREUM_MAINNET=<rpc_url> forge test --match-contract Fork_721Hook_Test -vvv
-contract Fork_721Hook_Test is Test {
-    using JBRulesetMetadataResolver for JBRuleset;
-
-    // =========================================================================
-    // Constants
-    // =========================================================================
-
-    address constant NATIVE_TOKEN = JBConstants.NATIVE_TOKEN;
-
-    // =========================================================================
-    // Actors
-    // =========================================================================
-
-    address multisig = address(0xBEEF);
-    address payer = makeAddr("payer");
-    address beneficiary = makeAddr("beneficiary");
-    address reserveBeneficiary = makeAddr("reserveBeneficiary");
-    address attacker = makeAddr("attacker");
-
-    // =========================================================================
-    // JB Core
-    // =========================================================================
-
-    JBPermissions jbPermissions;
-    JBProjects jbProjects;
-    JBDirectory jbDirectory;
-    JBRulesets jbRulesets;
-    JBTokens jbTokens;
-    JBSplits jbSplits;
-    JBFundAccessLimits jbFundAccessLimits;
-    JBFeelessAddresses jbFeelessAddresses;
-    JBPrices jbPrices;
-    JBController jbController;
-    JBTerminalStore jbTerminalStore;
-    JBMultiTerminal jbMultiTerminal;
-
-    // =========================================================================
-    // 721 Hook
-    // =========================================================================
-
-    JB721TiersHookStore store;
-    JB721TiersHook hookImpl;
-    JB721TiersHookDeployer hookDeployer;
-    JB721TiersHookProjectDeployer projectDeployer;
-    MetadataResolverHelper metadataHelper;
-    JBAddressRegistry addressRegistry;
-
-    // =========================================================================
-    // IPFS URIs (reusable)
-    // =========================================================================
-
-    bytes32 constant IPFS_URI = 0x7D5A99F603F231D53A4F39D1521F98D2E8BB279CF29BEBFD0687DC98458E7F89;
-
-    // =========================================================================
-    // Events (for expectEmit)
-    // =========================================================================
-
-    event Mint(
-        uint256 indexed tokenId,
-        uint256 indexed tierId,
-        address indexed beneficiary,
-        uint256 totalAmountPaid,
-        address caller
-    );
-    event Burn(uint256 indexed tokenId, address owner, address caller);
-
-    // =========================================================================
-    // Setup
-    // =========================================================================
-
-    /// @dev Accept ETH for cashout returns.
-    receive() external payable {}
-
-    function setUp() public {
-        vm.createSelectFork("ethereum");
-
-        _deployJBCore();
-        _deploy721Hook();
-
-        vm.deal(payer, 1000 ether);
-        vm.deal(beneficiary, 100 ether);
-        vm.deal(multisig, 100 ether);
-        vm.deal(attacker, 100 ether);
-
-        vm.label(multisig, "multisig");
-        vm.label(payer, "payer");
-        vm.label(beneficiary, "beneficiary");
-        vm.label(reserveBeneficiary, "reserveBeneficiary");
-        vm.label(attacker, "attacker");
-    }
-
-    // forge-lint: disable-next-line(mixed-case-function)
-    function _deployJBCore() internal {
-        jbPermissions = new JBPermissions(address(0));
-        jbProjects = new JBProjects(multisig, address(0), address(0));
-        jbDirectory = new JBDirectory(jbPermissions, jbProjects, multisig);
-        JBERC20 jbErc20 = new JBERC20(jbPermissions, jbProjects);
-        jbTokens = new JBTokens(jbDirectory, jbErc20);
-        jbRulesets = new JBRulesets(jbDirectory);
-        jbPrices = new JBPrices(jbDirectory, jbPermissions, jbProjects, multisig, address(0));
-        jbSplits = new JBSplits(jbDirectory);
-        jbFundAccessLimits = new JBFundAccessLimits(jbDirectory);
-        jbFeelessAddresses = new JBFeelessAddresses(multisig);
-
-        jbController = new JBController(
-            jbDirectory,
-            jbFundAccessLimits,
-            jbPermissions,
-            jbPrices,
-            jbProjects,
-            jbRulesets,
-            jbSplits,
-            jbTokens,
-            address(0), // omnichainRulesetOperator
-            address(0) // trustedForwarder
-        );
-
-        vm.prank(multisig);
-        jbDirectory.setIsAllowedToSetFirstController(address(jbController), true);
-
-        jbTerminalStore = new JBTerminalStore(jbDirectory, jbPrices, jbRulesets);
-
-        jbMultiTerminal = new JBMultiTerminal(
-            jbFeelessAddresses,
-            jbPermissions,
-            jbProjects,
-            jbSplits,
-            jbTerminalStore,
-            jbTokens,
-            IPermit2(address(0)), // Permit2 disabled for simplicity
-            address(0) // trustedForwarder
-        );
-
-        vm.label(address(jbPermissions), "JBPermissions");
-        vm.label(address(jbProjects), "JBProjects");
-        vm.label(address(jbDirectory), "JBDirectory");
-        vm.label(address(jbController), "JBController");
-        vm.label(address(jbMultiTerminal), "JBMultiTerminal");
-        vm.label(address(jbTerminalStore), "JBTerminalStore");
-    }
-
-    function _deploy721Hook() internal {
-        store = new JB721TiersHookStore();
-        hookImpl = new JB721TiersHook(
-            jbDirectory,
-            jbPermissions,
-            jbPrices,
-            jbRulesets,
-            store,
-            IJBSplits(address(jbSplits)),
-            IJB721CheckpointsDeployer(address(new JB721CheckpointsDeployer())),
-            address(0)
-        );
-        addressRegistry = new JBAddressRegistry();
-        hookDeployer = new JB721TiersHookDeployer(hookImpl, store, addressRegistry, address(0));
-        projectDeployer = new JB721TiersHookProjectDeployer(
-            IJBDirectory(jbDirectory), IJBPermissions(jbPermissions), hookDeployer, address(0)
-        );
-        metadataHelper = new MetadataResolverHelper();
-
-        vm.label(address(store), "JB721TiersHookStore");
-        vm.label(address(hookImpl), "JB721TiersHook_impl");
-        vm.label(address(projectDeployer), "JB721TiersHookProjectDeployer");
-    }
-
-    // =========================================================================
-    // Project Launch Helpers
-    // =========================================================================
-
-    /// @dev Launch a project with 721 hook. Returns projectId and hook address.
-    function _launchProject(
-        JB721TierConfig[] memory tierConfigs,
-        JB721TiersHookFlags memory flags,
-        uint16 cashOutTaxRate,
-        bool useDataHookForCashOut,
-        uint16 metadata721
-    )
-        internal
-        returns (uint256 projectId, address dataHook)
-    {
-        JBDeploy721TiersHookConfig memory hookConfig = JBDeploy721TiersHookConfig({
-            name: "TestNFT",
-            symbol: "TNFT",
-            baseUri: "ipfs://base/",
-            tokenUriResolver: IJB721TokenUriResolver(address(0)),
-            contractUri: "ipfs://contract",
-            tiersConfig: JB721InitTiersConfig({
-                // forge-lint: disable-next-line(unsafe-typecast)
-                tiers: tierConfigs,
-                // forge-lint: disable-next-line(unsafe-typecast)
-                currency: uint32(uint160(NATIVE_TOKEN)),
-                decimals: 18
-            }),
-            flags: flags
-        });
-
-        JBPayDataHookRulesetMetadata memory rulesetMetadata = JBPayDataHookRulesetMetadata({
-            reservedPercent: 5000, // 50%
-            cashOutTaxRate: cashOutTaxRate,
-            // forge-lint: disable-next-line(unsafe-typecast)
-            baseCurrency: uint32(uint160(NATIVE_TOKEN)),
-            pausePay: false,
-            pauseCreditTransfers: false,
-            allowOwnerMinting: true,
-            allowSetCustomToken: false,
-            allowTerminalMigration: false,
-            allowSetTerminals: false,
-            allowSetController: false,
-            allowAddAccountingContext: false,
-            allowAddPriceFeed: false,
-            ownerMustSendPayouts: false,
-            holdFees: false,
-            useTotalSurplusForCashOuts: false,
-            useDataHookForCashOut: useDataHookForCashOut,
-            metadata: metadata721
-        });
-
-        JBPayDataHookRulesetConfig[] memory rulesetConfigs = new JBPayDataHookRulesetConfig[](1);
-        rulesetConfigs[0].mustStartAtOrAfter = 0;
-        rulesetConfigs[0].duration = 0; // Never expires
-        rulesetConfigs[0].weight = 1_000_000e18; // 1M tokens per ETH
-        rulesetConfigs[0].weightCutPercent = 0;
-        rulesetConfigs[0].approvalHook = IJBRulesetApprovalHook(address(0));
-        rulesetConfigs[0].metadata = rulesetMetadata;
-
-        JBAccountingContext[] memory accountingContexts = new JBAccountingContext[](1);
-        accountingContexts[0] =
-        // forge-lint: disable-next-line(unsafe-typecast)
-        JBAccountingContext({token: NATIVE_TOKEN, currency: uint32(uint160(NATIVE_TOKEN)), decimals: 18});
-
-        JBTerminalConfig[] memory terminalConfigs = new JBTerminalConfig[](1);
-        terminalConfigs[0] =
-            JBTerminalConfig({terminal: jbMultiTerminal, accountingContextsToAccept: accountingContexts});
-
-        JBLaunchProjectConfig memory launchConfig = JBLaunchProjectConfig({
-            projectUri: "test-project",
-            rulesetConfigurations: rulesetConfigs,
-            terminalConfigurations: terminalConfigs,
-            memo: ""
-        });
-
-        IJB721TiersHook hookInstance;
-        (projectId, hookInstance) =
-            projectDeployer.launchProjectFor(multisig, hookConfig, launchConfig, jbController, bytes32(0));
-
-        dataHook = address(hookInstance);
-        vm.label(dataHook, "hook_clone");
-    }
-
-    /// @dev Shorthand: launch with standard 10 tiers, no flags, 50% tax, cash out data hook enabled.
-    function _launchStandardProject()
-        internal
-        returns (uint256 projectId, address dataHook, JB721TierConfig[] memory tierConfigs)
-    {
-        tierConfigs = _makeStandardTiers(10, 10, false);
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        (projectId, dataHook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-    }
-
-    function _makeStandardTiers(
-        uint256 count,
-        uint32 supplyPerTier,
-        bool allowOwnerMint
-    )
-        internal
-        view
-        returns (JB721TierConfig[] memory tierConfigs)
-    {
-        tierConfigs = new JB721TierConfig[](count);
-        for (uint256 i; i < count; i++) {
-            tierConfigs[i] = JB721TierConfig({
-                price: uint104((i + 1) * 0.01 ether),
-                initialSupply: supplyPerTier,
-                votingUnits: uint32((i + 1) * 10),
-                reserveFrequency: 10,
-                reserveBeneficiary: reserveBeneficiary,
-                encodedIPFSUri: IPFS_URI,
-                category: uint24(100),
-                discountPercent: 0,
-                flags: JB721TierConfigFlags({
-                    allowOwnerMint: allowOwnerMint,
-                    useReserveBeneficiaryAsDefault: false,
-                    transfersPausable: false,
-                    useVotingUnits: false,
-                    cantBeRemoved: false,
-                    cantIncreaseDiscountPercent: false,
-                    cantBuyWithCredits: false
-                }),
-                splitPercent: 0,
-                splits: new JBSplit[](0)
-            });
-        }
-    }
-
-    function _defaultFlags() internal pure returns (JB721TiersHookFlags memory) {
-        return JB721TiersHookFlags({
-            preventOverspending: false,
-            issueTokensForSplits: false,
-            noNewTiersWithReserves: false,
-            noNewTiersWithVotes: false,
-            noNewTiersWithOwnerMinting: false
-        });
-    }
-
-    // =========================================================================
-    // Metadata Building Helpers
-    // =========================================================================
-
-    /// @dev Build pay metadata that requests specific tier IDs. `allowOverspending` controls revert behavior.
-    function _buildPayMetadata(
-        address,
-        uint16[] memory tierIds,
-        bool allowOverspending
-    )
-        internal
-        view
-        returns (bytes memory)
-    {
-        bytes[] memory data = new bytes[](1);
-        data[0] = abi.encode(allowOverspending, tierIds);
-        bytes4[] memory ids = new bytes4[](1);
-        ids[0] = JBMetadataResolver.getId("pay", address(hookImpl));
-        return metadataHelper.createMetadata(ids, data);
-    }
-
-    /// @dev Build cash out metadata that specifies token IDs to burn.
-    function _buildCashOutMetadata(address, uint256[] memory tokenIds) internal view returns (bytes memory) {
-        bytes[] memory data = new bytes[](1);
-        data[0] = abi.encode(tokenIds);
-        bytes4[] memory ids = new bytes4[](1);
-        ids[0] = JBMetadataResolver.getId("cashOut", address(hookImpl));
-        return metadataHelper.createMetadata(ids, data);
-    }
-
-    // =========================================================================
-    // Token ID Helper
-    // =========================================================================
-
-    function _tokenId(uint256 tierId, uint256 mintNumber) internal pure returns (uint256) {
-        return tierId * 1_000_000_000 + mintNumber;
-    }
-
-    // =========================================================================
-    // Pay Helper
-    // =========================================================================
-
-    function _payAndMint(
-        uint256 projectId,
-        uint256 value,
-        uint16[] memory tierIds,
-        bool allowOverspending,
-        address hook
-    )
-        internal
-        returns (uint256 tokenCount)
-    {
-        bytes memory meta = _buildPayMetadata(hook, tierIds, allowOverspending);
-        vm.prank(payer);
-        tokenCount = jbMultiTerminal.pay{value: value}({
-            projectId: projectId,
-            amount: value,
-            token: NATIVE_TOKEN,
-            beneficiary: beneficiary,
-            minReturnedTokens: 0,
-            memo: "",
-            metadata: meta
-        });
-    }
-
-    // =====================================================================
-    // SECTION 1: BASIC LIFECYCLE
-    // =====================================================================
-
-    /// @notice Launch project, pay to mint 1 NFT, verify ownership and balance.
-    function test_fork_basicPayAndMint() public {
-        (uint256 projectId, address hook,) = _launchStandardProject();
-
-        // Mint from tier 1 (price = 0.01 ETH).
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1;
-
-        _payAndMint(projectId, 0.01 ether, tierIds, true, hook);
-
-        assertEq(IERC721(hook).balanceOf(beneficiary), 1, "should own 1 NFT");
-        assertEq(IERC721(hook).ownerOf(_tokenId(1, 1)), beneficiary, "beneficiary should own token");
-        assertEq(IJB721TiersHook(hook).firstOwnerOf(_tokenId(1, 1)), beneficiary, "firstOwner should be beneficiary");
-    }
-
-    /// @notice Pay to mint multiple NFTs from different tiers in one transaction.
-    function test_fork_multiTierMintInOnePay() public {
-        (uint256 projectId, address hook,) = _launchStandardProject();
-
-        // Mint from tiers 1, 3, 5 (prices: 0.01 + 0.03 + 0.05 = 0.09 ETH).
-        uint16[] memory tierIds = new uint16[](3);
-        tierIds[0] = 1;
-        tierIds[1] = 3;
-        tierIds[2] = 5;
-
-        _payAndMint(projectId, 0.09 ether, tierIds, true, hook);
-
-        assertEq(IERC721(hook).balanceOf(beneficiary), 3, "should own 3 NFTs");
-        assertEq(IERC721(hook).ownerOf(_tokenId(1, 1)), beneficiary, "owns tier 1 NFT");
-        assertEq(IERC721(hook).ownerOf(_tokenId(3, 1)), beneficiary, "owns tier 3 NFT");
-        assertEq(IERC721(hook).ownerOf(_tokenId(5, 1)), beneficiary, "owns tier 5 NFT");
-    }
-
-    /// @notice Mint multiple NFTs from the SAME tier in one payment.
-    function test_fork_duplicateTierMint() public {
-        (uint256 projectId, address hook,) = _launchStandardProject();
-
-        uint16[] memory tierIds = new uint16[](3);
-        tierIds[0] = 2;
-        tierIds[1] = 2;
-        tierIds[2] = 2;
-
-        _payAndMint(projectId, 0.06 ether, tierIds, true, hook);
-
-        assertEq(IERC721(hook).balanceOf(beneficiary), 3, "3 NFTs from same tier");
-
-        JB721Tier memory tier = store.tierOf(hook, 2, false);
-        assertEq(tier.remainingSupply, 7, "remaining supply should be 7");
-    }
-
-    // =====================================================================
-    // SECTION 2: CASH OUT (REDEEM) LIFECYCLE
-    // =====================================================================
-
-    /// @notice Pay, mint NFT, cash out. Verify ETH reclaim and NFT burn.
-    function test_fork_cashOutSingleNFT() public {
-        (uint256 projectId, address hook,) = _launchStandardProject();
-
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 5; // Price: 0.05 ETH
-
-        _payAndMint(projectId, 0.05 ether, tierIds, true, hook);
-
-        assertEq(IERC721(hook).balanceOf(beneficiary), 1, "should own 1 NFT");
-
-        // Cash out the NFT.
-        uint256[] memory tokensToCashOut = new uint256[](1);
-        tokensToCashOut[0] = _tokenId(5, 1);
-        bytes memory cashOutMeta = _buildCashOutMetadata(hook, tokensToCashOut);
-
-        uint256 balBefore = beneficiary.balance;
-        vm.prank(beneficiary);
-        jbMultiTerminal.cashOutTokensOf({
-            holder: beneficiary,
-            projectId: projectId,
-            tokenToReclaim: NATIVE_TOKEN,
-            cashOutCount: 0,
-            minTokensReclaimed: 0,
-            beneficiary: payable(beneficiary),
-            metadata: cashOutMeta
-        });
-
-        assertEq(IERC721(hook).balanceOf(beneficiary), 0, "NFT should be burned");
-        assertEq(store.numberOfBurnedFor(hook, 5), 1, "burn should be recorded");
-        assertGt(beneficiary.balance, balBefore, "should have reclaimed some ETH");
-    }
-
-    /// @notice Pay with multiple tiers, cash out all at once.
-    function test_fork_cashOutMultipleNFTs() public {
-        (uint256 projectId, address hook,) = _launchStandardProject();
-
-        uint16[] memory tierIds = new uint16[](3);
-        tierIds[0] = 1;
-        tierIds[1] = 2;
-        tierIds[2] = 3;
-
-        _payAndMint(projectId, 0.06 ether, tierIds, true, hook);
-
-        uint256[] memory tokensToCashOut = new uint256[](3);
-        tokensToCashOut[0] = _tokenId(1, 1);
-        tokensToCashOut[1] = _tokenId(2, 1);
-        tokensToCashOut[2] = _tokenId(3, 1);
-        bytes memory cashOutMeta = _buildCashOutMetadata(hook, tokensToCashOut);
-
-        vm.prank(beneficiary);
-        jbMultiTerminal.cashOutTokensOf({
-            holder: beneficiary,
-            projectId: projectId,
-            tokenToReclaim: NATIVE_TOKEN,
-            cashOutCount: 0,
-            minTokensReclaimed: 0,
-            beneficiary: payable(beneficiary),
-            metadata: cashOutMeta
-        });
-
-        assertEq(IERC721(hook).balanceOf(beneficiary), 0, "all NFTs burned");
-    }
-
-    /// @notice With 0% cash out tax rate, reclaim should be proportional to NFT weight.
-    function test_fork_cashOutWithZeroTaxRate() public {
-        JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 10, false);
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 0, true, 0x00); // 0% tax
-
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1;
-        _payAndMint(projectId, 0.01 ether, tierIds, true, hook);
-
-        uint256[] memory tokensToCashOut = new uint256[](1);
-        tokensToCashOut[0] = _tokenId(1, 1);
-        bytes memory cashOutMeta = _buildCashOutMetadata(hook, tokensToCashOut);
-
-        uint256 balBefore = beneficiary.balance;
-        vm.prank(beneficiary);
-        jbMultiTerminal.cashOutTokensOf({
-            holder: beneficiary,
-            projectId: projectId,
-            tokenToReclaim: NATIVE_TOKEN,
-            cashOutCount: 0,
-            minTokensReclaimed: 0,
-            beneficiary: payable(beneficiary),
-            metadata: cashOutMeta
-        });
-
-        // With 0% tax and single NFT, should reclaim nearly all (minus fee).
-        uint256 reclaimed = beneficiary.balance - balBefore;
-        assertGt(reclaimed, 0, "should reclaim ETH");
-    }
-
-    // =====================================================================
-    // SECTION 3: PAY CREDITS
-    // =====================================================================
-
-    /// @notice Overpayment when no tier IDs specified should accumulate credits.
-    function test_fork_payCreditsAccumulation() public {
-        (uint256 projectId, address hook,) = _launchStandardProject();
-
-        // Pay without specifying tier IDs → all ETH becomes credits.
-        vm.prank(payer);
-        jbMultiTerminal.pay{value: 0.5 ether}({
-            projectId: projectId,
-            amount: 0.5 ether,
-            token: NATIVE_TOKEN,
-            beneficiary: beneficiary,
-            minReturnedTokens: 0,
-            memo: "",
-            metadata: new bytes(0)
-        });
-
-        assertEq(IERC721(hook).balanceOf(beneficiary), 0, "no NFT minted");
-        assertEq(IJB721TiersHook(hook).payCreditsOf(beneficiary), 0.5 ether, "credits should equal payment");
-    }
-
-    /// @notice Overpayment with tier IDs specified should mint the requested tier and credit the rest.
-    function test_fork_overpayAccumulatesCredits() public {
-        (uint256 projectId, address hook,) = _launchStandardProject();
-
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1; // 0.01 ETH
-
-        _payAndMint(projectId, 0.05 ether, tierIds, true, hook);
-
-        assertEq(IERC721(hook).balanceOf(beneficiary), 1, "1 NFT minted");
-        assertEq(IJB721TiersHook(hook).payCreditsOf(beneficiary), 0.04 ether, "leftover credited");
-    }
-
-    /// @notice Credits should be used on subsequent self-pay (payer == beneficiary).
-    function test_fork_payCreditsUsedOnSelfPay() public {
-        (uint256 projectId, address hook,) = _launchStandardProject();
-
-        // First: accumulate credits.
-        vm.prank(payer);
-        jbMultiTerminal.pay{value: 0.005 ether}({
-            projectId: projectId,
-            amount: 0.005 ether,
-            token: NATIVE_TOKEN,
-            beneficiary: payer, // payer == beneficiary for credit usage
-            minReturnedTokens: 0,
-            memo: "",
-            metadata: new bytes(0)
-        });
-
-        assertEq(IJB721TiersHook(hook).payCreditsOf(payer), 0.005 ether, "credits stored");
-
-        // Second: pay 0.005 more, combined with 0.005 credits = 0.01, enough for tier 1.
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1;
-
-        bytes memory meta = _buildPayMetadata(hook, tierIds, true);
-        vm.prank(payer);
-        jbMultiTerminal.pay{value: 0.005 ether}({
-            projectId: projectId,
-            amount: 0.005 ether,
-            token: NATIVE_TOKEN,
-            beneficiary: payer,
-            minReturnedTokens: 0,
-            memo: "",
-            metadata: meta
-        });
-
-        assertEq(IERC721(hook).balanceOf(payer), 1, "NFT minted using credits + payment");
-        assertEq(IJB721TiersHook(hook).payCreditsOf(payer), 0, "credits consumed");
-    }
-
-    /// @notice Credits should NOT be combined when payer != beneficiary.
-    function test_fork_payCreditsNotUsedWhenPayerDifferent() public {
-        (uint256 projectId, address hook,) = _launchStandardProject();
-
-        // Accumulate credits for beneficiary.
-        vm.prank(payer);
-        jbMultiTerminal.pay{value: 0.1 ether}({
-            projectId: projectId,
-            amount: 0.1 ether,
-            token: NATIVE_TOKEN,
-            beneficiary: beneficiary,
-            minReturnedTokens: 0,
-            memo: "",
-            metadata: new bytes(0)
-        });
-
-        uint256 creditsBefore = IJB721TiersHook(hook).payCreditsOf(beneficiary);
-        assertEq(creditsBefore, 0.1 ether, "beneficiary has credits");
-
-        // Pay from a different payer on behalf of beneficiary — credits should NOT be combined.
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1; // 0.01 ETH
-
-        // Attacker pays 0.01 ETH on behalf of beneficiary.
-        bytes memory meta = _buildPayMetadata(hook, tierIds, true);
-        vm.prank(attacker);
-        jbMultiTerminal.pay{value: 0.01 ether}({
-            projectId: projectId,
-            amount: 0.01 ether,
-            token: NATIVE_TOKEN,
-            beneficiary: beneficiary,
-            minReturnedTokens: 0,
-            memo: "",
-            metadata: meta
-        });
-
-        // Credits should remain unchanged (payer != beneficiary, credits not consumed).
-        assertEq(IJB721TiersHook(hook).payCreditsOf(beneficiary), creditsBefore, "credits unchanged");
-    }
-
-    // =====================================================================
-    // SECTION 4: FLAGS
-    // =====================================================================
-
-    /// @notice preventOverspending: reverts if leftover after minting.
-    function test_fork_preventOverspending_reverts() public {
-        JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 10, false);
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        flags.preventOverspending = true;
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-
-        // Pay 0.05 ETH for a 0.01 ETH tier — 0.04 leftover should cause revert.
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1;
-
-        bytes memory meta = _buildPayMetadata(hook, tierIds, false);
-
-        vm.prank(payer);
-        vm.expectRevert();
-        jbMultiTerminal.pay{value: 0.05 ether}({
-            projectId: projectId,
-            amount: 0.05 ether,
-            token: NATIVE_TOKEN,
-            beneficiary: beneficiary,
-            minReturnedTokens: 0,
-            memo: "",
-            metadata: meta
-        });
-    }
-
-    /// @notice preventOverspending: exact payment should succeed.
-    function test_fork_preventOverspending_exactPaySucceeds() public {
-        JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 10, false);
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        flags.preventOverspending = true;
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1;
-
-        bytes memory meta = _buildPayMetadata(hook, tierIds, false);
-
-        vm.prank(payer);
-        jbMultiTerminal.pay{value: 0.01 ether}({
-            projectId: projectId,
-            amount: 0.01 ether,
-            token: NATIVE_TOKEN,
-            beneficiary: beneficiary,
-            minReturnedTokens: 0,
-            memo: "",
-            metadata: meta
-        });
-
-        assertEq(IERC721(hook).balanceOf(beneficiary), 1, "exact pay minted 1 NFT");
-    }
-
-    /// @notice noNewTiersWithReserves: adding a tier with reserveFrequency should revert.
-    function test_fork_noNewTiersWithReserves_reverts() public {
-        JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 10, false);
-        tierConfigs[0].reserveFrequency = 0; // Initial tier has no reserves (allowed).
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        flags.noNewTiersWithReserves = true;
-        (, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-
-        // Try to add a new tier with reserves.
-        JB721TierConfig[] memory newTiers = new JB721TierConfig[](1);
-        newTiers[0] = JB721TierConfig({
-            price: 0.1 ether,
-            initialSupply: 10,
-            votingUnits: 0,
-            reserveFrequency: 5,
-            reserveBeneficiary: reserveBeneficiary,
-            encodedIPFSUri: IPFS_URI,
-            category: 200,
-            discountPercent: 0,
-            flags: JB721TierConfigFlags({
-                allowOwnerMint: false,
-                useReserveBeneficiaryAsDefault: false,
-                transfersPausable: false,
-                useVotingUnits: false,
-                cantBeRemoved: false,
-                cantIncreaseDiscountPercent: false,
-                cantBuyWithCredits: false
-            }),
-            splitPercent: 0,
-            splits: new JBSplit[](0)
-        });
-
-        vm.prank(multisig);
-        vm.expectRevert();
-        IJB721TiersHook(hook).adjustTiers(newTiers, new uint256[](0));
-    }
-
-    /// @notice noNewTiersWithOwnerMinting: adding a tier with allowOwnerMint should revert.
-    function test_fork_noNewTiersWithOwnerMinting_reverts() public {
-        JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 10, false);
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        flags.noNewTiersWithOwnerMinting = true;
-        (, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-
-        JB721TierConfig[] memory newTiers = new JB721TierConfig[](1);
-        newTiers[0] = JB721TierConfig({
-            price: 0.1 ether,
-            initialSupply: 10,
-            votingUnits: 0,
-            reserveFrequency: 0,
-            reserveBeneficiary: address(0),
-            encodedIPFSUri: IPFS_URI,
-            category: 200,
-            discountPercent: 0,
-            flags: JB721TierConfigFlags({
-                allowOwnerMint: true,
-                useReserveBeneficiaryAsDefault: false,
-                transfersPausable: false,
-                useVotingUnits: false,
-                cantBeRemoved: false,
-                cantIncreaseDiscountPercent: false,
-                cantBuyWithCredits: false
-            }),
-            splitPercent: 0,
-            splits: new JBSplit[](0)
-        });
-
-        vm.prank(multisig);
-        vm.expectRevert();
-        IJB721TiersHook(hook).adjustTiers(newTiers, new uint256[](0));
-    }
-
-    /// @notice cantBeRemoved: removing an immutable tier should revert.
-    function test_fork_cantBeRemoved_reverts() public {
-        JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 10, false);
-        tierConfigs[0].flags.cantBeRemoved = true;
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        (, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-
-        uint256[] memory toRemove = new uint256[](1);
-        toRemove[0] = 1;
-
-        vm.prank(multisig);
-        vm.expectRevert();
-        IJB721TiersHook(hook).adjustTiers(new JB721TierConfig[](0), toRemove);
-    }
-
-    // =====================================================================
-    // SECTION 5: DISCOUNTS
-    // =====================================================================
-
-    /// @notice Mint at a discounted price. Discount of 100 = 50% off.
-    function test_fork_discountedMint() public {
-        JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 10, false);
-        tierConfigs[0].price = 1 ether;
-        tierConfigs[0].discountPercent = 100; // 50% off → effective price = 0.5 ETH
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1;
-
-        // Pay exactly 1 ETH — should mint at 0.5 ETH effective price, leftover 0.5 ETH as credits.
-        _payAndMint(projectId, 1 ether, tierIds, true, hook);
-
-        assertEq(IERC721(hook).balanceOf(beneficiary), 1, "NFT minted at discounted price");
-        assertEq(IJB721TiersHook(hook).payCreditsOf(beneficiary), 0.5 ether, "leftover credited");
-    }
-
-    /// @notice Full discount (200 = 100% off) makes tier free.
-    function test_fork_fullDiscount_freeMint() public {
-        JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 10, false);
-        tierConfigs[0].price = 1 ether;
-        tierConfigs[0].discountPercent = 200; // 100% off → free
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1;
-
-        // Mint with 0 ETH — should work since effective price is 0.
-        bytes memory meta = _buildPayMetadata(hook, tierIds, true);
-        vm.prank(payer);
-        jbMultiTerminal.pay{value: 0}({
-            projectId: projectId,
-            amount: 0,
-            token: NATIVE_TOKEN,
-            beneficiary: beneficiary,
-            minReturnedTokens: 0,
-            memo: "",
-            metadata: meta
-        });
-
-        assertEq(IERC721(hook).balanceOf(beneficiary), 1, "NFT minted for free");
-    }
-
-    /// @notice cantIncreaseDiscountPercent: setting higher discount reverts.
-    function test_fork_cannotIncreaseDiscount() public {
-        JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 10, false);
-        tierConfigs[0].discountPercent = 50;
-        tierConfigs[0].flags.cantIncreaseDiscountPercent = true;
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        (, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-
-        vm.prank(multisig);
-        vm.expectRevert();
-        IJB721TiersHook(hook).setDiscountPercentOf(1, 100);
-
-        // Decreasing should work.
-        vm.prank(multisig);
-        IJB721TiersHook(hook).setDiscountPercentOf(1, 25);
-
-        JB721Tier memory tier = store.tierOf(hook, 1, false);
-        assertEq(tier.discountPercent, 25, "discount decreased");
-    }
-
-    // =====================================================================
-    // SECTION 6: RESERVE MINTING
-    // =====================================================================
-
-    /// @notice Pay enough to trigger pending reserves, then mint them.
-    function test_fork_reserveMintLifecycle() public {
-        (uint256 projectId, address hook,) = _launchStandardProject();
-
-        // Mint 5 NFTs from tier 1 (reserve frequency = 10 → ceil(5/10) = 1 pending reserve).
-        uint16[] memory tierIds = new uint16[](5);
-        for (uint256 i; i < 5; i++) {
-            tierIds[i] = 1;
-        }
-
-        _payAndMint(projectId, 0.05 ether, tierIds, true, hook);
-
-        uint256 pending = store.numberOfPendingReservesFor(hook, 1);
-        assertGt(pending, 0, "should have pending reserves");
-
-        // Mint the pending reserves.
-        vm.prank(multisig);
-        IJB721TiersHook(hook).mintPendingReservesFor(1, pending);
-
-        assertEq(store.numberOfPendingReservesFor(hook, 1), 0, "no pending reserves after mint");
-        assertGt(IERC721(hook).balanceOf(reserveBeneficiary), 0, "reserve beneficiary received NFTs");
-    }
-
-    /// @notice Minting more pending reserves than available should revert.
-    function test_fork_reserveMint_tooMany_reverts() public {
-        (uint256 projectId, address hook,) = _launchStandardProject();
-
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1;
-
-        _payAndMint(projectId, 0.01 ether, tierIds, true, hook);
-
-        uint256 pending = store.numberOfPendingReservesFor(hook, 1);
-
-        vm.prank(multisig);
-        vm.expectRevert();
-        IJB721TiersHook(hook).mintPendingReservesFor(1, pending + 10);
-    }
-
-    /// @notice Reserve frequency = 1: every paid mint generates a pending reserve.
-    function test_fork_highReserveFrequency() public {
-        JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 100, false);
-        tierConfigs[0].reserveFrequency = 1;
-        tierConfigs[0].reserveBeneficiary = reserveBeneficiary;
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-
-        // Mint 5 paid NFTs.
-        uint16[] memory tierIds = new uint16[](5);
-        for (uint256 i; i < 5; i++) {
-            tierIds[i] = 1;
-        }
-
-        _payAndMint(projectId, 0.05 ether, tierIds, true, hook);
-
-        uint256 pending = store.numberOfPendingReservesFor(hook, 1);
-        assertGt(pending, 0, "high frequency means many pending reserves");
-
-        vm.prank(multisig);
-        IJB721TiersHook(hook).mintPendingReservesFor(1, pending);
-
-        assertEq(store.numberOfPendingReservesFor(hook, 1), 0, "all reserves minted");
-    }
-
-    // =====================================================================
-    // SECTION 7: TRANSFER PAUSING
-    // =====================================================================
-
-    /// @notice transfersPausable tier flag + ruleset metadata pauses transfers.
-    function test_fork_transfersPaused_reverts() public {
-        JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 10, false);
-        tierConfigs[0].flags.transfersPausable = true;
-        JB721TiersHookFlags memory flags = _defaultFlags();
-
-        // Pack 721 metadata: bit 0 = pauseTransfers = true.
-        uint16 packed721Meta = uint16(
-            // forge-lint: disable-next-line(named-struct-fields)
-            JB721TiersRulesetMetadataResolver.pack721TiersRulesetMetadata(JB721TiersRulesetMetadata(true, false))
-        );
-
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 5000, true, packed721Meta);
-
-        // Mint an NFT.
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1;
-        _payAndMint(projectId, 0.01 ether, tierIds, true, hook);
-
-        // Try to transfer — should revert.
-        vm.prank(beneficiary);
-        vm.expectRevert();
-        IERC721(hook).transferFrom(beneficiary, attacker, _tokenId(1, 1));
-    }
-
-    /// @notice Transfer works when transfersPausable=true but ruleset metadata doesn't pause.
-    function test_fork_transfersPausable_notPaused_works() public {
-        JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 10, false);
-        tierConfigs[0].flags.transfersPausable = true;
-        JB721TiersHookFlags memory flags = _defaultFlags();
-
-        // 721 metadata: transfers NOT paused.
-        uint16 packed721Meta = uint16(
-            // forge-lint: disable-next-line(named-struct-fields)
-            JB721TiersRulesetMetadataResolver.pack721TiersRulesetMetadata(JB721TiersRulesetMetadata(false, false))
-        );
-
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 5000, true, packed721Meta);
-
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1;
-        _payAndMint(projectId, 0.01 ether, tierIds, true, hook);
-
-        // Transfer should succeed.
-        vm.prank(beneficiary);
-        IERC721(hook).transferFrom(beneficiary, attacker, _tokenId(1, 1));
-
-        assertEq(IERC721(hook).ownerOf(_tokenId(1, 1)), attacker, "transfer succeeded");
-    }
-
-    // =====================================================================
-    // SECTION 8: MINT PENDING RESERVES PAUSED
-    // =====================================================================
-
-    /// @notice mintPendingReserves paused via ruleset metadata.
-    function test_fork_mintPendingReservesPaused_reverts() public {
-        JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 100, false);
-        tierConfigs[0].reserveFrequency = 1;
-        tierConfigs[0].reserveBeneficiary = reserveBeneficiary;
-        JB721TiersHookFlags memory flags = _defaultFlags();
-
-        // 721 metadata: bit 1 = pauseMintPendingReserves = true.
-        uint16 packed721Meta = uint16(
-            // forge-lint: disable-next-line(named-struct-fields)
-            JB721TiersRulesetMetadataResolver.pack721TiersRulesetMetadata(JB721TiersRulesetMetadata(false, true))
-        );
-
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 5000, true, packed721Meta);
-
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1;
-        _payAndMint(projectId, 0.01 ether, tierIds, true, hook);
-
-        uint256 pending = store.numberOfPendingReservesFor(hook, 1);
-        assertGt(pending, 0, "should have pending reserves");
-
-        vm.prank(multisig);
-        vm.expectRevert();
-        IJB721TiersHook(hook).mintPendingReservesFor(1, 1);
-    }
-
-    // =====================================================================
-    // SECTION 9: OWNER MINTING (mintFor)
-    // =====================================================================
-
-    /// @notice Owner can mint via mintFor when allowOwnerMint is set on tier.
-    function test_fork_ownerMint() public {
-        JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 10, true); // allowOwnerMint=true
-        tierConfigs[0].reserveFrequency = 0; // No reserves (required: can't have both).
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        (, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-
-        uint16[] memory tierIds = new uint16[](2);
-        tierIds[0] = 1;
-        tierIds[1] = 1;
-
-        vm.prank(multisig);
-        IJB721TiersHook(hook).mintFor(tierIds, beneficiary);
-
-        assertEq(IERC721(hook).balanceOf(beneficiary), 2, "owner minted 2 NFTs");
-    }
-
-    /// @notice Non-owner cannot mintFor.
-    function test_fork_ownerMint_noPermission_reverts() public {
-        JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 10, true);
-        tierConfigs[0].reserveFrequency = 0;
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        (, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1;
-
-        vm.prank(attacker);
-        vm.expectRevert();
-        IJB721TiersHook(hook).mintFor(tierIds, attacker);
-    }
-
-    // =====================================================================
-    // SECTION 10: TIER MANAGEMENT
-    // =====================================================================
-
-    /// @notice Add tiers after launch, mint from new tier.
-    function test_fork_addTiersAndMint() public {
-        (uint256 projectId, address hook,) = _launchStandardProject();
-
-        // Add a new expensive tier.
-        JB721TierConfig[] memory newTiers = new JB721TierConfig[](1);
-        newTiers[0] = JB721TierConfig({
-            price: 1 ether,
-            initialSupply: 5,
-            votingUnits: 100,
-            reserveFrequency: 0,
-            reserveBeneficiary: address(0),
-            encodedIPFSUri: IPFS_URI,
-            category: 200,
-            discountPercent: 0,
-            flags: JB721TierConfigFlags({
-                allowOwnerMint: false,
-                useReserveBeneficiaryAsDefault: false,
-                transfersPausable: false,
-                useVotingUnits: false,
-                cantBeRemoved: false,
-                cantIncreaseDiscountPercent: false,
-                cantBuyWithCredits: false
-            }),
-            splitPercent: 0,
-            splits: new JBSplit[](0)
-        });
-
-        vm.prank(multisig);
-        IJB721TiersHook(hook).adjustTiers(newTiers, new uint256[](0));
-
-        // Tier 11 should now exist.
-        JB721Tier memory newTier = store.tierOf(hook, 11, false);
-        assertEq(newTier.price, 1 ether, "new tier price");
-        assertEq(newTier.initialSupply, 5, "new tier supply");
-
-        // Mint from the new tier.
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 11;
-
-        _payAndMint(projectId, 1 ether, tierIds, true, hook);
-
-        assertEq(IERC721(hook).ownerOf(_tokenId(11, 1)), beneficiary, "minted from new tier");
-    }
-
-    /// @notice Remove a tier, verify minting from it fails.
-    function test_fork_removeTierBlocksMinting() public {
-        (uint256 projectId, address hook,) = _launchStandardProject();
-
-        uint256[] memory toRemove = new uint256[](1);
-        toRemove[0] = 3;
-
-        vm.prank(multisig);
-        IJB721TiersHook(hook).adjustTiers(new JB721TierConfig[](0), toRemove);
-
-        // Try to mint from removed tier — should revert (supply=0 after removal).
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 3;
-
-        bytes memory meta = _buildPayMetadata(hook, tierIds, false);
-
-        vm.prank(payer);
-        vm.expectRevert();
-        jbMultiTerminal.pay{value: 0.03 ether}({
-            projectId: projectId,
-            amount: 0.03 ether,
-            token: NATIVE_TOKEN,
-            beneficiary: beneficiary,
-            minReturnedTokens: 0,
-            memo: "",
-            metadata: meta
-        });
-    }
-
-    // =====================================================================
-    // SECTION 11: SUPPLY EXHAUSTION
-    // =====================================================================
-
-    /// @notice Exhaust supply, then verify further minting reverts.
-    function test_fork_supplyExhaustion() public {
-        JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 3, false); // Only 3 NFTs
-        tierConfigs[0].reserveFrequency = 0;
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-
-        // Mint all 3.
-        uint16[] memory tierIds = new uint16[](3);
-        tierIds[0] = 1;
-        tierIds[1] = 1;
-        tierIds[2] = 1;
-
-        _payAndMint(projectId, 0.03 ether, tierIds, true, hook);
-
-        assertEq(IERC721(hook).balanceOf(beneficiary), 3, "all 3 minted");
-
-        JB721Tier memory tier = store.tierOf(hook, 1, false);
-        assertEq(tier.remainingSupply, 0, "supply exhausted");
-
-        // Try to mint one more — should revert.
-        uint16[] memory oneMore = new uint16[](1);
-        oneMore[0] = 1;
-
-        bytes memory meta = _buildPayMetadata(hook, oneMore, false);
-
-        vm.prank(payer);
-        vm.expectRevert();
-        jbMultiTerminal.pay{value: 0.01 ether}({
-            projectId: projectId,
-            amount: 0.01 ether,
-            token: NATIVE_TOKEN,
-            beneficiary: beneficiary,
-            minReturnedTokens: 0,
-            memo: "",
-            metadata: meta
-        });
-    }
-
-    // =====================================================================
-    // SECTION 12: ERC-721 BEHAVIOR
-    // =====================================================================
-
-    /// @notice firstOwnerOf tracks correctly through transfers.
-    function test_fork_firstOwnerOfTracksAcrossTransfers() public {
-        (uint256 projectId, address hook,) = _launchStandardProject();
-
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1;
-        _payAndMint(projectId, 0.01 ether, tierIds, true, hook);
-
-        uint256 tokenId = _tokenId(1, 1);
-        assertEq(IJB721TiersHook(hook).firstOwnerOf(tokenId), beneficiary, "initial firstOwner");
-
-        // Transfer to attacker.
-        vm.prank(beneficiary);
-        IERC721(hook).transferFrom(beneficiary, attacker, tokenId);
-        assertEq(IERC721(hook).ownerOf(tokenId), attacker, "attacker owns");
-        assertEq(IJB721TiersHook(hook).firstOwnerOf(tokenId), beneficiary, "firstOwner unchanged");
-
-        // Transfer again.
-        vm.prank(attacker);
-        IERC721(hook).transferFrom(attacker, payer, tokenId);
-        assertEq(IJB721TiersHook(hook).firstOwnerOf(tokenId), beneficiary, "firstOwner still beneficiary");
-    }
-
-    /// @notice Approval and transferFrom by approved operator.
-    function test_fork_approvalAndTransfer() public {
-        (uint256 projectId, address hook,) = _launchStandardProject();
-
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1;
-        _payAndMint(projectId, 0.01 ether, tierIds, true, hook);
-
-        uint256 tokenId = _tokenId(1, 1);
-
-        // Approve attacker.
-        vm.prank(beneficiary);
-        IERC721(hook).approve(attacker, tokenId);
-
-        // Attacker transfers using approval.
-        vm.prank(attacker);
-        IERC721(hook).transferFrom(beneficiary, attacker, tokenId);
-
-        assertEq(IERC721(hook).ownerOf(tokenId), attacker, "attacker now owns via approval");
-    }
-
-    // =====================================================================
-    // SECTION 13: VOTING UNITS
-    // =====================================================================
-
-    /// @notice Price-based voting (useVotingUnits=false) uses tier price as voting power.
-    function test_fork_priceBasedVoting() public {
-        (uint256 projectId, address hook,) = _launchStandardProject();
-
-        // Mint from tier 5 (price = 0.05 ETH, useVotingUnits=false → price-based).
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 5;
-        _payAndMint(projectId, 0.05 ether, tierIds, true, hook);
-
-        uint256 votingPower = store.votingUnitsOf(hook, beneficiary);
-        assertEq(votingPower, 0.05 ether, "voting power should equal tier price");
-    }
-
-    /// @notice Custom voting units (useVotingUnits=true) uses specified value.
-    function test_fork_customVotingUnits() public {
-        JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 10, false);
-        tierConfigs[0].flags.useVotingUnits = true;
-        tierConfigs[0].votingUnits = 42;
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1;
-        _payAndMint(projectId, 0.01 ether, tierIds, true, hook);
-
-        uint256 votingPower = store.votingUnitsOf(hook, beneficiary);
-        assertEq(votingPower, 42, "voting power should be custom units");
-    }
-
-    // =====================================================================
-    // SECTION 14: CASH OUT WEIGHT AND MATH
-    // =====================================================================
-
-    /// @notice Cash out weight uses original price (not discounted).
-    function test_fork_cashOutWeightUsesOriginalPrice() public {
-        JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 10, false);
-        tierConfigs[0].price = 1 ether;
-        tierConfigs[0].discountPercent = 100; // 50% discount
-        tierConfigs[0].reserveFrequency = 0;
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1;
-        _payAndMint(projectId, 1 ether, tierIds, true, hook);
-
-        // Cash out weight should be based on original price (1 ETH), not discounted (0.5 ETH).
-        uint256[] memory tokenIds = new uint256[](1);
-        tokenIds[0] = _tokenId(1, 1);
-        uint256 weight = store.cashOutWeightOf(hook, tokenIds);
-        assertEq(weight, 1 ether, "cash out weight uses original price");
-    }
-
-    /// @notice totalCashOutWeight includes pending reserves in denominator.
-    function test_fork_totalCashOutWeightIncludesPendingReserves() public {
-        JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 100, false);
-        tierConfigs[0].price = 1 ether;
-        tierConfigs[0].reserveFrequency = 1;
-        tierConfigs[0].reserveBeneficiary = reserveBeneficiary;
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1;
-        _payAndMint(projectId, 1 ether, tierIds, true, hook);
-
-        uint256 totalWeight = store.totalCashOutWeight(hook);
-
-        // 1 paid mint + pending reserves. Total weight > just 1 * price.
-        assertGt(totalWeight, 1 ether, "total weight includes pending reserves");
-    }
-
-    // =====================================================================
-    // SECTION 15: ADVERSARIAL — FLASH LOAN ATTACK
-    // =====================================================================
-
-    /// @notice Pay and cash out in same block — verify no profit (bonding curve prevents it).
-    function test_fork_flashLoanAttack_noProfit() public {
-        JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 100, false);
-        tierConfigs[0].price = 1 ether;
-        tierConfigs[0].reserveFrequency = 0;
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00); // 50% tax
-
-        // Seed with initial payments from payer — minting NFTs so totalCashOutWeight is large.
-        uint16[] memory seedTierIds = new uint16[](10);
-        for (uint256 i; i < 10; i++) {
-            seedTierIds[i] = 1;
-        }
-        bytes memory seedMeta = _buildPayMetadata(hook, seedTierIds, true);
-        vm.prank(payer);
-        jbMultiTerminal.pay{value: 10 ether}({
-            projectId: projectId,
-            amount: 10 ether,
-            token: NATIVE_TOKEN,
-            beneficiary: payer,
-            minReturnedTokens: 0,
-            memo: "",
-            metadata: seedMeta
-        });
-
-        uint256 attackerBalBefore = attacker.balance;
-
-        // Attacker: pay → mint NFT → immediately cash out.
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1;
-        bytes memory payMeta = _buildPayMetadata(hook, tierIds, true);
-
-        vm.prank(attacker);
-        jbMultiTerminal.pay{value: 1 ether}({
-            projectId: projectId,
-            amount: 1 ether,
-            token: NATIVE_TOKEN,
-            beneficiary: attacker,
-            minReturnedTokens: 0,
-            memo: "",
-            metadata: payMeta
-        });
-
-        uint256[] memory tokensToCashOut = new uint256[](1);
-        tokensToCashOut[0] = _tokenId(1, 11); // Token #11 (first 10 minted by payer)
-        bytes memory cashOutMeta = _buildCashOutMetadata(hook, tokensToCashOut);
-
-        vm.prank(attacker);
-        jbMultiTerminal.cashOutTokensOf({
-            holder: attacker,
-            projectId: projectId,
-            tokenToReclaim: NATIVE_TOKEN,
-            cashOutCount: 0,
-            minTokensReclaimed: 0,
-            beneficiary: payable(attacker),
-            metadata: cashOutMeta
-        });
-
-        // Attacker should not have profited.
-        assertLe(attacker.balance, attackerBalBefore, "flash loan attack should not profit");
-    }
-
-    // =====================================================================
-    // SECTION 16: ADVERSARIAL — NON-OWNER CASH OUT
-    // =====================================================================
-
-    /// @notice Non-owner trying to cash out someone else's NFT should revert.
-    function test_fork_nonOwnerCashOut_reverts() public {
-        (uint256 projectId, address hook,) = _launchStandardProject();
-
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1;
-        _payAndMint(projectId, 0.01 ether, tierIds, true, hook);
-
-        // beneficiary owns the NFT. attacker tries to cash out.
-        uint256[] memory tokensToCashOut = new uint256[](1);
-        tokensToCashOut[0] = _tokenId(1, 1);
-        bytes memory cashOutMeta = _buildCashOutMetadata(hook, tokensToCashOut);
-
-        vm.prank(attacker);
-        vm.expectRevert();
-        jbMultiTerminal.cashOutTokensOf({
-            holder: attacker,
-            projectId: projectId,
-            tokenToReclaim: NATIVE_TOKEN,
-            cashOutCount: 0,
-            minTokensReclaimed: 0,
-            beneficiary: payable(attacker),
-            metadata: cashOutMeta
-        });
-    }
-
-    // =====================================================================
-    // SECTION 17: ADVERSARIAL — RE-INITIALIZATION
-    // =====================================================================
-
-    /// @notice Calling initialize() again on a deployed hook should revert.
-    function test_fork_reInitialize_reverts() public {
-        (, address hook,) = _launchStandardProject();
-
-        JB721TierConfig[] memory emptyTiers = new JB721TierConfig[](0);
-
-        vm.expectRevert();
-        IJB721TiersHook(hook)
-            .initialize(
-                99, // different projectId
-                "Evil",
-                "EVIL",
-                "ipfs://evil/",
-                IJB721TokenUriResolver(address(0)),
-                "ipfs://evil-contract",
-                // forge-lint: disable-next-line(unsafe-typecast)
-                JB721InitTiersConfig({tiers: emptyTiers, currency: uint32(uint160(NATIVE_TOKEN)), decimals: 18}),
-                _defaultFlags()
-            );
-    }
-
-    // =====================================================================
-    // SECTION 18: ADVERSARIAL — UNDERPAY
-    // =====================================================================
-
-    /// @notice Paying less than tier price with preventOverspending=true should revert.
-    function test_fork_underpay_reverts() public {
-        JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 10, false);
-        tierConfigs[0].price = 1 ether;
-        tierConfigs[0].reserveFrequency = 0;
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        flags.preventOverspending = true;
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1;
-
-        bytes memory meta = _buildPayMetadata(hook, tierIds, false);
-
-        vm.prank(payer);
-        vm.expectRevert();
-        jbMultiTerminal.pay{value: 0.5 ether}({
-            projectId: projectId,
-            amount: 0.5 ether,
-            token: NATIVE_TOKEN,
-            beneficiary: beneficiary,
-            minReturnedTokens: 0,
-            memo: "",
-            metadata: meta
-        });
-    }
-
-    // =====================================================================
-    // SECTION 19: ADVERSARIAL — ADJUSTTIERS WITHOUT PERMISSION
-    // =====================================================================
-
-    /// @notice Non-owner cannot adjustTiers.
-    function test_fork_adjustTiers_noPermission_reverts() public {
-        (, address hook,) = _launchStandardProject();
-
-        JB721TierConfig[] memory newTiers = new JB721TierConfig[](1);
-        newTiers[0] = JB721TierConfig({
-            price: 0.001 ether,
-            initialSupply: type(uint32).max,
-            votingUnits: 0,
-            reserveFrequency: 0,
-            reserveBeneficiary: attacker,
-            encodedIPFSUri: IPFS_URI,
-            category: 200,
-            discountPercent: 0,
-            flags: JB721TierConfigFlags({
-                allowOwnerMint: false,
-                useReserveBeneficiaryAsDefault: false,
-                transfersPausable: false,
-                useVotingUnits: false,
-                cantBeRemoved: false,
-                cantIncreaseDiscountPercent: false,
-                cantBuyWithCredits: false
-            }),
-            splitPercent: 0,
-            splits: new JBSplit[](0)
-        });
-
-        vm.prank(attacker);
-        vm.expectRevert();
-        IJB721TiersHook(hook).adjustTiers(newTiers, new uint256[](0));
-    }
-
-    // =====================================================================
-    // SECTION 20: ADVERSARIAL — STALE CASH OUT WEIGHT AFTER REMOVAL
-    // =====================================================================
-
-    /// @notice Mint from a tier, remove it, verify totalCashOutWeight still includes minted tokens.
-    function test_fork_cashOutWeightPreservedAfterTierRemoval() public {
-        (uint256 projectId, address hook,) = _launchStandardProject();
-
-        uint16[] memory tierIds = new uint16[](3);
-        tierIds[0] = 5;
-        tierIds[1] = 5;
-        tierIds[2] = 5;
-        _payAndMint(projectId, 0.15 ether, tierIds, true, hook);
-
-        uint256 weightBefore = store.totalCashOutWeight(hook);
-        assertGt(weightBefore, 0, "should have weight");
-
-        // Remove tier 5.
-        uint256[] memory toRemove = new uint256[](1);
-        toRemove[0] = 5;
-
-        vm.prank(multisig);
-        IJB721TiersHook(hook).adjustTiers(new JB721TierConfig[](0), toRemove);
-
-        uint256 weightAfter = store.totalCashOutWeight(hook);
-        assertEq(weightAfter, weightBefore, "weight preserved after tier removal");
-    }
-
-    // =====================================================================
-    // SECTION 21: MULTI-USER SCENARIOS
-    // =====================================================================
-
-    /// @notice Multiple users pay and mint from same project.
-    function test_fork_multipleUsersMinting() public {
-        (uint256 projectId, address hook,) = _launchStandardProject();
-
-        address user1 = makeAddr("user1");
-        address user2 = makeAddr("user2");
-        address user3 = makeAddr("user3");
-        vm.deal(user1, 10 ether);
-        vm.deal(user2, 10 ether);
-        vm.deal(user3, 10 ether);
-
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1;
-
-        // User1 mints.
-        bytes memory meta = _buildPayMetadata(hook, tierIds, true);
-        vm.prank(user1);
-        jbMultiTerminal.pay{value: 0.01 ether}({
-            projectId: projectId,
-            amount: 0.01 ether,
-            token: NATIVE_TOKEN,
-            beneficiary: user1,
-            minReturnedTokens: 0,
-            memo: "",
-            metadata: meta
-        });
-
-        // User2 mints.
-        vm.prank(user2);
-        jbMultiTerminal.pay{value: 0.01 ether}({
-            projectId: projectId,
-            amount: 0.01 ether,
-            token: NATIVE_TOKEN,
-            beneficiary: user2,
-            minReturnedTokens: 0,
-            memo: "",
-            metadata: meta
-        });
-
-        // User3 mints.
-        vm.prank(user3);
-        jbMultiTerminal.pay{value: 0.01 ether}({
-            projectId: projectId,
-            amount: 0.01 ether,
-            token: NATIVE_TOKEN,
-            beneficiary: user3,
-            minReturnedTokens: 0,
-            memo: "",
-            metadata: meta
-        });
-
-        assertEq(IERC721(hook).balanceOf(user1), 1, "user1 has 1 NFT");
-        assertEq(IERC721(hook).balanceOf(user2), 1, "user2 has 1 NFT");
-        assertEq(IERC721(hook).balanceOf(user3), 1, "user3 has 1 NFT");
-
-        // Each user got a different token number.
-        assertEq(IERC721(hook).ownerOf(_tokenId(1, 1)), user1, "user1 has #1");
-        assertEq(IERC721(hook).ownerOf(_tokenId(1, 2)), user2, "user2 has #2");
-        assertEq(IERC721(hook).ownerOf(_tokenId(1, 3)), user3, "user3 has #3");
-
-        JB721Tier memory tier = store.tierOf(hook, 1, false);
-        assertEq(tier.remainingSupply, 7, "supply decreased by 3");
-    }
-
-    // =====================================================================
-    // SECTION 22: FULL LIFECYCLE — PAY, MINT, RESERVE, CASH OUT, REMINT
-    // =====================================================================
-
-    /// @notice Complete lifecycle: pay → mint → reserves → cash out → verify store consistency.
-    function test_fork_fullLifecycle() public {
-        JB721TierConfig[] memory tierConfigs = _makeStandardTiers(3, 20, false);
-        tierConfigs[0].reserveFrequency = 5;
-        tierConfigs[1].reserveFrequency = 5;
-        tierConfigs[2].reserveFrequency = 5;
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-
-        // Phase 1: Multiple payments minting various tiers.
-        uint16[] memory batch1 = new uint16[](3);
-        batch1[0] = 1;
-        batch1[1] = 1;
-        batch1[2] = 2;
-        _payAndMint(projectId, 0.04 ether, batch1, true, hook);
-
-        uint16[] memory batch2 = new uint16[](2);
-        batch2[0] = 2;
-        batch2[1] = 3;
-        _payAndMint(projectId, 0.05 ether, batch2, true, hook);
-
-        assertEq(IERC721(hook).balanceOf(beneficiary), 5, "5 NFTs total");
-
-        // Phase 2: Mint pending reserves.
-        for (uint256 tierId = 1; tierId <= 3; tierId++) {
-            uint256 pending = store.numberOfPendingReservesFor(hook, tierId);
-            if (pending > 0) {
-                vm.prank(multisig);
-                IJB721TiersHook(hook).mintPendingReservesFor(tierId, pending);
-            }
-        }
-
-        assertGt(IERC721(hook).balanceOf(reserveBeneficiary), 0, "reserve beneficiary has NFTs");
-
-        // Phase 3: Cash out some NFTs.
-        uint256[] memory tokensToCashOut = new uint256[](2);
-        tokensToCashOut[0] = _tokenId(1, 1);
-        tokensToCashOut[1] = _tokenId(2, 1);
-        bytes memory cashOutMeta = _buildCashOutMetadata(hook, tokensToCashOut);
-
-        uint256 balBefore = beneficiary.balance;
-        vm.prank(beneficiary);
-        jbMultiTerminal.cashOutTokensOf({
-            holder: beneficiary,
-            projectId: projectId,
-            tokenToReclaim: NATIVE_TOKEN,
-            cashOutCount: 0,
-            minTokensReclaimed: 0,
-            beneficiary: payable(beneficiary),
-            metadata: cashOutMeta
-        });
-
-        assertEq(IERC721(hook).balanceOf(beneficiary), 3, "3 NFTs remaining");
-        assertGt(beneficiary.balance, balBefore, "ETH reclaimed");
-        assertEq(store.numberOfBurnedFor(hook, 1), 1, "tier 1 burn recorded");
-        assertEq(store.numberOfBurnedFor(hook, 2), 1, "tier 2 burn recorded");
-
-        // Phase 4: Re-mint from depleted tiers — supply should still be available.
-        uint16[] memory reMint = new uint16[](1);
-        reMint[0] = 1;
-        _payAndMint(projectId, 0.01 ether, reMint, true, hook);
-
-        assertEq(IERC721(hook).balanceOf(beneficiary), 4, "4 NFTs after remint");
-    }
-
-    // =====================================================================
-    // SECTION 23: ZERO PRICE TIER
-    // =====================================================================
-
-    /// @notice A zero-price tier can be minted for free.
-    function test_fork_zeroPriceTier() public {
-        JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 10, false);
-        tierConfigs[0].price = 0;
-        tierConfigs[0].reserveFrequency = 0;
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1;
-
-        bytes memory meta = _buildPayMetadata(hook, tierIds, true);
-        vm.prank(payer);
-        jbMultiTerminal.pay{value: 0}({
-            projectId: projectId,
-            amount: 0,
-            token: NATIVE_TOKEN,
-            beneficiary: beneficiary,
-            minReturnedTokens: 0,
-            memo: "",
-            metadata: meta
-        });
-
-        assertEq(IERC721(hook).balanceOf(beneficiary), 1, "zero price tier minted");
-    }
-
-    // =====================================================================
-    // SECTION 24: DETERMINISTIC DEPLOYMENT
-    // =====================================================================
-
-    /// @notice Deterministic and non-deterministic clone deployments both work.
-    function test_fork_deterministicDeployment() public {
-        JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 10, false);
-        tierConfigs[0].reserveFrequency = 0;
-        JB721TiersHookFlags memory flags = _defaultFlags();
-
-        // Non-deterministic.
-        (uint256 projectId1, address hook1) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-        assertGt(projectId1, 0, "project 1 launched");
-        assertTrue(hook1.code.length > 0, "hook 1 deployed");
-
-        // Verify registered in address registry.
-        assertEq(addressRegistry.deployerOf(hook1), address(hookDeployer), "hook 1 in registry");
-    }
-
-    // =====================================================================
-    // SECTION 25: MULTI-CATEGORY TIERS
-    // =====================================================================
-
-    /// @notice Tiers across multiple categories can be minted independently.
-    function test_fork_multiCategoryTiers() public {
-        JB721TierConfig[] memory tierConfigs = new JB721TierConfig[](3);
-        for (uint256 i; i < 3; i++) {
-            tierConfigs[i] = JB721TierConfig({
-                price: uint104((i + 1) * 0.01 ether),
-                initialSupply: 10,
-                votingUnits: 0,
-                reserveFrequency: 0,
-                reserveBeneficiary: address(0),
-                encodedIPFSUri: IPFS_URI,
-                category: uint24((i + 1) * 100), // Categories: 100, 200, 300
-                discountPercent: 0,
-                flags: JB721TierConfigFlags({
-                    allowOwnerMint: false,
-                    useReserveBeneficiaryAsDefault: false,
-                    transfersPausable: false,
-                    useVotingUnits: false,
-                    cantBeRemoved: false,
-                    cantIncreaseDiscountPercent: false,
-                    cantBuyWithCredits: false
-                }),
-                splitPercent: 0,
-                splits: new JBSplit[](0)
-            });
-        }
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-
-        // Mint from each category.
-        uint16[] memory tierIds = new uint16[](3);
-        tierIds[0] = 1;
-        tierIds[1] = 2;
-        tierIds[2] = 3;
-
-        _payAndMint(projectId, 0.06 ether, tierIds, true, hook);
-
-        assertEq(IERC721(hook).balanceOf(beneficiary), 3, "one from each category");
-
-        // Query tiers by category.
-        uint256[] memory cat100 = new uint256[](1);
-        cat100[0] = 100;
-        JB721Tier[] memory cat100Tiers = store.tiersOf(hook, cat100, false, 0, 100);
-        assertEq(cat100Tiers.length, 1, "1 tier in category 100");
-    }
-
-    // =====================================================================
-    // SECTION 26: PAY WITHOUT METADATA — NO TIERS SPECIFIED
-    // =====================================================================
-
-    /// @notice Paying without metadata gives all payment as credits.
-    function test_fork_payWithoutMetadata_noNFTsMinted() public {
-        (uint256 projectId, address hook,) = _launchStandardProject();
-
-        vm.prank(payer);
-        jbMultiTerminal.pay{value: 1 ether}({
-            projectId: projectId,
-            amount: 1 ether,
-            token: NATIVE_TOKEN,
-            beneficiary: beneficiary,
-            minReturnedTokens: 0,
-            memo: "",
-            metadata: new bytes(0)
-        });
-
-        assertEq(IERC721(hook).balanceOf(beneficiary), 0, "no NFTs minted");
-        assertEq(IJB721TiersHook(hook).payCreditsOf(beneficiary), 1 ether, "full payment as credits");
-    }
-
-    // =====================================================================
-    // SECTION 27: M6 RESERVE PROTECTION
-    // =====================================================================
-
-    /// @notice M6: Cannot mint past pending reserves. If remaining supply would drop below
-    ///         pending reserves, the paid mint reverts.
-    function test_fork_m6_reserveProtection() public {
-        // Supply=4, reserveFrequency=1.
-        // After 2 paid mints: remaining=2, pendingReserves = ceil(2/1) = 2+1 = 3? No:
-        // Formula: nonReserveMints = initialSupply - remaining - reservesMinted = 4-2-0 = 2
-        // pendingReserves = ceil(2/1) - 0 = 2
-        // remaining(2) >= pending(2) → OK (M6 checks remaining < pending, not <=)
-        // After 3rd paid mint attempt: remaining would be 1
-        // nonReserveMints = 4-1-0 = 3, pending = ceil(3/1) - 0 = 3
-        // remaining(1) < pending(3) → REVERTS!
-        // So: mint 2, then 3rd should revert.
-        JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 4, false);
-        tierConfigs[0].reserveFrequency = 1;
-        tierConfigs[0].reserveBeneficiary = reserveBeneficiary;
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-
-        // Mint 2 NFTs successfully.
-        uint16[] memory two = new uint16[](2);
-        two[0] = 1;
-        two[1] = 1;
-        _payAndMint(projectId, 0.02 ether, two, true, hook);
-
-        assertEq(IERC721(hook).balanceOf(beneficiary), 2, "2 minted successfully");
-
-        // 3rd mint should fail — remaining would drop below pending reserves.
-        uint16[] memory one = new uint16[](1);
-        one[0] = 1;
-        bytes memory meta = _buildPayMetadata(hook, one, false);
-
-        vm.prank(payer);
-        vm.expectRevert();
-        jbMultiTerminal.pay{value: 0.01 ether}({
-            projectId: projectId,
-            amount: 0.01 ether,
-            token: NATIVE_TOKEN,
-            beneficiary: beneficiary,
-            minReturnedTokens: 0,
-            memo: "",
-            metadata: meta
-        });
-    }
-
-    // =====================================================================
-    // SECTION 28: CASH OUT RECLAIM CONSISTENCY
-    // =====================================================================
-
-    /// @notice Two users mint same tier. Higher tax rate should yield less reclaim.
-    function test_fork_cashOutTaxRateEffect() public {
-        // High tax rate project.
-        JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 100, false);
-        tierConfigs[0].price = 1 ether;
-        tierConfigs[0].reserveFrequency = 0;
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 9000, true, 0x00); // 90% tax
-
-        // First user pays.
-        address user1 = makeAddr("taxUser1");
-        vm.deal(user1, 10 ether);
-
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1;
-
-        bytes memory meta = _buildPayMetadata(hook, tierIds, true);
-        vm.prank(user1);
-        jbMultiTerminal.pay{value: 1 ether}({
-            projectId: projectId,
-            amount: 1 ether,
-            token: NATIVE_TOKEN,
-            beneficiary: user1,
-            minReturnedTokens: 0,
-            memo: "",
-            metadata: meta
-        });
-
-        // Second user pays.
-        address user2 = makeAddr("taxUser2");
-        vm.deal(user2, 10 ether);
-        vm.prank(user2);
-        jbMultiTerminal.pay{value: 1 ether}({
-            projectId: projectId,
-            amount: 1 ether,
-            token: NATIVE_TOKEN,
-            beneficiary: user2,
-            minReturnedTokens: 0,
-            memo: "",
-            metadata: meta
-        });
-
-        // User1 cashes out — with 90% tax, they should get very little back.
-        uint256[] memory tokensToCashOut = new uint256[](1);
-        tokensToCashOut[0] = _tokenId(1, 1);
-        bytes memory cashOutMeta = _buildCashOutMetadata(hook, tokensToCashOut);
-
-        uint256 balBefore = user1.balance;
-        vm.prank(user1);
-        jbMultiTerminal.cashOutTokensOf({
-            holder: user1,
-            projectId: projectId,
-            tokenToReclaim: NATIVE_TOKEN,
-            cashOutCount: 0,
-            minTokensReclaimed: 0,
-            beneficiary: payable(user1),
-            metadata: cashOutMeta
-        });
-
-        uint256 reclaimed = user1.balance - balBefore;
-        // With 90% tax, should get less than what was paid (1 ETH).
-        assertLt(reclaimed, 1 ether, "90% tax should yield less than paid");
-    }
-
-    // =====================================================================
-    // SECTION 29: MULTIPLE PROJECTS SHARING SAME STORE
-    // =====================================================================
-
-    /// @notice Two projects using the same store should not interfere with each other.
-    function test_fork_crossProjectIsolation() public {
-        JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 10, false);
-        tierConfigs[0].reserveFrequency = 0;
-        JB721TiersHookFlags memory flags = _defaultFlags();
-
-        (uint256 projectId1, address hook1) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-        (, address hook2) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-
-        assertTrue(hook1 != hook2, "hooks are different clones");
-
-        // Mint from project 1.
-        uint16[] memory tierIds = new uint16[](3);
-        tierIds[0] = 1;
-        tierIds[1] = 1;
-        tierIds[2] = 1;
-        bytes memory meta1 = _buildPayMetadata(hook1, tierIds, true);
-        vm.prank(payer);
-        jbMultiTerminal.pay{value: 0.03 ether}({
-            projectId: projectId1,
-            amount: 0.03 ether,
-            token: NATIVE_TOKEN,
-            beneficiary: beneficiary,
-            minReturnedTokens: 0,
-            memo: "",
-            metadata: meta1
-        });
-
-        // Project 2's supply should be unaffected.
-        JB721Tier memory p2Tier = store.tierOf(hook2, 1, false);
-        assertEq(p2Tier.remainingSupply, 10, "project 2 supply unaffected");
-
-        // Project 1's supply should be decreased.
-        JB721Tier memory p1Tier = store.tierOf(hook1, 1, false);
-        assertEq(p1Tier.remainingSupply, 7, "project 1 supply decreased");
-    }
-
-    // =====================================================================
-    // SECTION 30: BURN AFTER CASH OUT AND REMINT
-    // =====================================================================
-
-    /// @notice After burning via cash out, new mints get different token numbers.
-    function test_fork_tokenNumbersAfterBurn() public {
-        JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 100, false);
-        tierConfigs[0].reserveFrequency = 0;
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 0, true, 0x00);
-
-        // Mint token #1.
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1;
-        _payAndMint(projectId, 0.01 ether, tierIds, true, hook);
-
-        assertEq(IERC721(hook).ownerOf(_tokenId(1, 1)), beneficiary, "token #1 exists");
-
-        // Cash out token #1 (burn it).
-        uint256[] memory toCashOut = new uint256[](1);
-        toCashOut[0] = _tokenId(1, 1);
-        bytes memory cashOutMeta = _buildCashOutMetadata(hook, toCashOut);
-        vm.prank(beneficiary);
-        jbMultiTerminal.cashOutTokensOf({
-            holder: beneficiary,
-            projectId: projectId,
-            tokenToReclaim: NATIVE_TOKEN,
-            cashOutCount: 0,
-            minTokensReclaimed: 0,
-            beneficiary: payable(beneficiary),
-            metadata: cashOutMeta
-        });
-
-        // Mint again — should get token #2, not #1 (burned tokens don't recycle numbers).
-        _payAndMint(projectId, 0.01 ether, tierIds, true, hook);
-
-        assertEq(IERC721(hook).ownerOf(_tokenId(1, 2)), beneficiary, "token #2 after burn");
-
-        // Token #1 should no longer exist (burned).
-        vm.expectRevert();
-        IERC721(hook).ownerOf(_tokenId(1, 1));
-    }
-
-    // =====================================================================
-    // SECTION 31: TIER SPLITS
-    /// @dev Helper: build a single split tier config.
-    function _makeSplitTierConfig(
-        uint104 price,
-        uint32 splitPct,
-        JBSplit[] memory splits,
-        uint24 category
-    )
-        internal
-        pure
-        returns (JB721TierConfig memory)
-    {
-        return JB721TierConfig({
-            price: price,
-            initialSupply: 10,
-            votingUnits: 0,
-            reserveFrequency: 0,
-            reserveBeneficiary: address(0),
-            encodedIPFSUri: IPFS_URI,
-            category: category,
-            discountPercent: 0,
-            flags: JB721TierConfigFlags({
-                allowOwnerMint: false,
-                useReserveBeneficiaryAsDefault: false,
-                transfersPausable: false,
-                useVotingUnits: false,
-                cantBeRemoved: false,
-                cantIncreaseDiscountPercent: false,
-                cantBuyWithCredits: false
-            }),
-            splitPercent: splitPct,
-            splits: splits
-        });
-    }
-
-    /// @notice A tier with splitPercent routes that portion of the payment to the split beneficiary.
-    ///         The payer's token weight is reduced by the split fraction.
-    function test_fork_tierSplit_routesFundsToSplitBeneficiary() public {
-        address splitReceiver = makeAddr("splitReceiver");
-
-        JBSplit[] memory splits = new JBSplit[](1);
-        splits[0] = JBSplit({
-            preferAddToBalance: false,
-            percent: uint32(JBConstants.SPLITS_TOTAL_PERCENT), // 100% of split amount goes to this beneficiary
-            projectId: 0,
-            beneficiary: payable(splitReceiver),
-            lockedUntil: 0,
-            hook: IJBSplitHook(address(0))
-        });
-
-        JB721TierConfig[] memory tierConfigs = new JB721TierConfig[](1);
-        tierConfigs[0] = _makeSplitTierConfig(1 ether, uint32(JBConstants.SPLITS_TOTAL_PERCENT / 2), splits, 100);
-
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-
-        // Pay 1 ETH to mint the tier (tier ID = 1, since it's the first added).
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1;
-        uint256 tokensMinted = _payAndMint(projectId, 1 ether, tierIds, true, hook);
-
-        // Split receiver should have received 0.5 ETH (50% of 1 ETH tier price).
-        assertEq(splitReceiver.balance, 0.5 ether, "split receiver got 50%");
-
-        // Beneficiary should own the NFT.
-        assertEq(IERC721(hook).ownerOf(_tokenId(1, 1)), beneficiary, "NFT minted to beneficiary");
-
-        // Token weight is reduced by split: weight = 1M * (1 - 0.5) = 500k tokens/ETH.
-        // Then 50% reserved percent halves it further: payer gets 250k tokens.
-        assertEq(tokensMinted, 250_000e18, "tokens minted for non-split portion (after reserved)");
-    }
-
-    /// @notice When issueTokensForSplits is true, payer gets full token credit despite splits.
-    function test_fork_tierSplit_issueTokensForSplits() public {
-        address splitReceiver = makeAddr("splitReceiver");
-
-        JBSplit[] memory splits = new JBSplit[](1);
-        splits[0] = JBSplit({
-            preferAddToBalance: false,
-            percent: uint32(JBConstants.SPLITS_TOTAL_PERCENT),
-            projectId: 0,
-            beneficiary: payable(splitReceiver),
-            lockedUntil: 0,
-            hook: IJBSplitHook(address(0))
-        });
-
-        JB721TierConfig[] memory tierConfigs = new JB721TierConfig[](1);
-        tierConfigs[0] = _makeSplitTierConfig(1 ether, uint32(JBConstants.SPLITS_TOTAL_PERCENT / 2), splits, 100);
-
-        // Enable issueTokensForSplits.
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        flags.issueTokensForSplits = true;
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1;
-        uint256 tokensMinted = _payAndMint(projectId, 1 ether, tierIds, true, hook);
-
-        // Split receiver still gets their ETH.
-        assertEq(splitReceiver.balance, 0.5 ether, "split receiver got 50%");
-
-        // Payer gets FULL token credit (weight not reduced by split).
-        // 1M tokens/ETH * 1 ETH * (1 - 50% reserved) = 500k tokens.
-        assertEq(tokensMinted, 500_000e18, "full tokens despite split (after reserved)");
-    }
-
-    /// @notice Mix of tiers: one with splits, one without. Only the split tier routes funds.
-    function test_fork_tierSplit_mixedTiers() public {
-        address splitReceiver = makeAddr("splitReceiver");
-
-        JBSplit[] memory splits = new JBSplit[](1);
-        splits[0] = JBSplit({
-            preferAddToBalance: false,
-            percent: uint32(JBConstants.SPLITS_TOTAL_PERCENT),
-            projectId: 0,
-            beneficiary: payable(splitReceiver),
-            lockedUntil: 0,
-            hook: IJBSplitHook(address(0))
-        });
-
-        JB721TierConfig[] memory tierConfigs = new JB721TierConfig[](2);
-        // Tier 1: no splits (0.5 ETH).
-        tierConfigs[0] = _makeSplitTierConfig(0.5 ether, 0, new JBSplit[](0), 100);
-        // Tier 2: 50% split (0.5 ETH) → 0.25 ETH routed. Higher category for sort order.
-        tierConfigs[1] = _makeSplitTierConfig(0.5 ether, uint32(JBConstants.SPLITS_TOTAL_PERCENT / 2), splits, 200);
-
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-
-        // Mint both tiers (total: 1 ETH).
-        uint16[] memory tierIds = new uint16[](2);
-        tierIds[0] = 1;
-        tierIds[1] = 2;
-        uint256 tokensMinted = _payAndMint(projectId, 1 ether, tierIds, true, hook);
-
-        // Split receiver gets 0.25 ETH (50% of tier 2's 0.5 ETH price).
-        assertEq(splitReceiver.balance, 0.25 ether, "split receiver got 50% of tier 2 price");
-
-        // Both NFTs minted.
-        assertEq(IERC721(hook).ownerOf(_tokenId(1, 1)), beneficiary, "tier 1 NFT minted");
-        assertEq(IERC721(hook).ownerOf(_tokenId(2, 1)), beneficiary, "tier 2 NFT minted");
-
-        // Weight reduced by split fraction: 1M * (1 - 0.25) / 1 = 750k, then 50% reserved = 375k.
-        assertEq(tokensMinted, 375_000e18, "tokens reduced by split fraction (after reserved)");
-    }
-
-    /// @notice Split with no valid recipient (no projectId, no beneficiary) sends funds
-    ///         back into the project's terminal balance as leftover.
-    function test_fork_tierSplit_preferAddToBalance() public {
-        JBSplit[] memory splits = new JBSplit[](1);
-        splits[0] = JBSplit({
-            preferAddToBalance: true,
-            percent: uint32(JBConstants.SPLITS_TOTAL_PERCENT),
-            projectId: 0,
-            beneficiary: payable(address(0)),
-            lockedUntil: 0,
-            hook: IJBSplitHook(address(0))
-        });
-
-        JB721TierConfig[] memory tierConfigs = new JB721TierConfig[](1);
-        tierConfigs[0] = _makeSplitTierConfig(1 ether, uint32(JBConstants.SPLITS_TOTAL_PERCENT), splits, 100);
-
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1;
-        _payAndMint(projectId, 1 ether, tierIds, true, hook);
-
-        // NFT still minted.
-        assertEq(IERC721(hook).ownerOf(_tokenId(1, 1)), beneficiary, "NFT minted");
-
-        // All 1 ETH should be in the project's terminal balance (split had no valid recipient,
-        // so leftover is added back to balance).
-        uint256 projectBalance = jbTerminalStore.balanceOf(address(jbMultiTerminal), projectId, NATIVE_TOKEN);
-        assertEq(projectBalance, 1 ether, "full amount in project balance");
-    }
-
-    /// @notice 100% split with valid receiver means weight goes to zero (no project tokens minted).
-    function test_fork_tierSplit_fullSplitZerosWeight() public {
-        address splitReceiver = makeAddr("splitReceiver");
-
-        JBSplit[] memory splits = new JBSplit[](1);
-        splits[0] = JBSplit({
-            preferAddToBalance: false,
-            percent: uint32(JBConstants.SPLITS_TOTAL_PERCENT),
-            projectId: 0,
-            beneficiary: payable(splitReceiver),
-            lockedUntil: 0,
-            hook: IJBSplitHook(address(0))
-        });
-
-        JB721TierConfig[] memory tierConfigs = new JB721TierConfig[](1);
-        tierConfigs[0] = _makeSplitTierConfig(1 ether, uint32(JBConstants.SPLITS_TOTAL_PERCENT), splits, 100);
-
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1;
-        uint256 tokensMinted = _payAndMint(projectId, 1 ether, tierIds, true, hook);
-
-        // All funds routed to split receiver.
-        assertEq(splitReceiver.balance, 1 ether, "split receiver got 100%");
-
-        // Zero project tokens minted (weight set to 0 when splits consume entire payment).
-        assertEq(tokensMinted, 0, "zero tokens when full split");
-
-        // NFT still minted.
-        assertEq(IERC721(hook).ownerOf(_tokenId(1, 1)), beneficiary, "NFT still minted");
-    }
-
-    /// @notice Split to another Juicebox project (via pay into its terminal).
-    function test_fork_tierSplit_toProject() public {
-        address splitReceiver = makeAddr("splitReceiver");
-
-        // First launch a receiver project (simple, no hooks).
-        JBRulesetMetadata memory receiverMetadata = JBRulesetMetadata({
-            reservedPercent: 0,
-            cashOutTaxRate: 0,
-            // forge-lint: disable-next-line(unsafe-typecast)
-            baseCurrency: uint32(uint160(NATIVE_TOKEN)),
-            pausePay: false,
-            pauseCreditTransfers: false,
-            allowOwnerMinting: false,
-            allowSetCustomToken: false,
-            allowTerminalMigration: false,
-            allowSetTerminals: false,
-            allowSetController: false,
-            allowAddAccountingContext: false,
-            allowAddPriceFeed: false,
-            ownerMustSendPayouts: false,
-            holdFees: false,
-            useTotalSurplusForCashOuts: false,
-            useDataHookForPay: false,
-            useDataHookForCashOut: false,
-            dataHook: address(0),
-            metadata: 0
-        });
-
-        JBRulesetConfig[] memory receiverRulesets = new JBRulesetConfig[](1);
-        receiverRulesets[0] = JBRulesetConfig({
-            mustStartAtOrAfter: 0,
-            duration: 0,
-            weight: 1_000_000e18,
-            weightCutPercent: 0,
-            approvalHook: IJBRulesetApprovalHook(address(0)),
-            metadata: receiverMetadata,
-            splitGroups: new JBSplitGroup[](0),
-            fundAccessLimitGroups: new JBFundAccessLimitGroup[](0)
-        });
-
-        JBAccountingContext[] memory receiverAccounting = new JBAccountingContext[](1);
-        receiverAccounting[0] =
-        // forge-lint: disable-next-line(unsafe-typecast)
-        JBAccountingContext({token: NATIVE_TOKEN, currency: uint32(uint160(NATIVE_TOKEN)), decimals: 18});
-        JBTerminalConfig[] memory receiverTerminals = new JBTerminalConfig[](1);
-        receiverTerminals[0] =
-            JBTerminalConfig({terminal: jbMultiTerminal, accountingContextsToAccept: receiverAccounting});
-
-        vm.prank(multisig);
-        uint256 receiverProjectId = jbController.launchProjectFor({
-            owner: multisig,
-            projectUri: "receiver-project",
-            rulesetConfigurations: receiverRulesets,
-            terminalConfigurations: receiverTerminals,
-            memo: ""
-        });
-
-        // Now create the 721 hook project with a split that pays into the receiver project.
-        JBSplit[] memory splits = new JBSplit[](1);
-        splits[0] = JBSplit({
-            preferAddToBalance: false,
-            percent: uint32(JBConstants.SPLITS_TOTAL_PERCENT),
-            // forge-lint: disable-next-line(unsafe-typecast)
-            projectId: uint56(receiverProjectId),
-            beneficiary: payable(splitReceiver),
-            lockedUntil: 0,
-            hook: IJBSplitHook(address(0))
-        });
-
-        JB721TierConfig[] memory tierConfigs = new JB721TierConfig[](1);
-        tierConfigs[0] = _makeSplitTierConfig(1 ether, uint32(JBConstants.SPLITS_TOTAL_PERCENT / 2), splits, 100);
-
-        JB721TiersHookFlags memory flags = _defaultFlags();
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-
-        uint16[] memory tierIds = new uint16[](1);
-        tierIds[0] = 1;
-        _payAndMint(projectId, 1 ether, tierIds, true, hook);
-
-        // Receiver project should have 0.5 ETH in its balance.
-        uint256 receiverBalance = jbTerminalStore.balanceOf(address(jbMultiTerminal), receiverProjectId, NATIVE_TOKEN);
-        assertEq(receiverBalance, 0.5 ether, "receiver project got split funds");
-    }
-}