@bananapus/721-hook-v6 0.0.13 → 0.0.15

package/test/Fork.t.sol

@@ -122,12 +122,7 @@ contract Fork_721Hook_Test is Test {
     receive() external payable {}
 
     function setUp() public {
-        string memory rpcUrl = vm.envOr("RPC_ETHEREUM_MAINNET", string(""));
-        if (bytes(rpcUrl).length == 0) {
-            vm.skip(true);
-            return;
-        }
-        vm.createSelectFork(rpcUrl);
+        vm.createSelectFork("ethereum");
 
         _deployJBCore();
         _deploy721Hook();
@@ -244,6 +239,7 @@ contract Fork_721Hook_Test is Test {
             pausePay: false,
             pauseCreditTransfers: false,
             allowOwnerMinting: true,
+            allowSetCustomToken: false,
             allowTerminalMigration: false,
             allowSetTerminals: false,
             allowSetController: false,
@@ -345,7 +341,7 @@ contract Fork_721Hook_Test is Test {
 
     /// @dev Build pay metadata that requests specific tier IDs. `allowOverspending` controls revert behavior.
     function _buildPayMetadata(
-        address hook,
+        address,
         uint16[] memory tierIds,
         bool allowOverspending
     )
@@ -361,7 +357,7 @@ contract Fork_721Hook_Test is Test {
     }
 
     /// @dev Build cash out metadata that specifies token IDs to burn.
-    function _buildCashOutMetadata(address hook, uint256[] memory tokenIds) internal view returns (bytes memory) {
+    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);
@@ -734,7 +730,7 @@ contract Fork_721Hook_Test is Test {
         tierConfigs[0].reserveFrequency = 0; // Initial tier has no reserves (allowed).
         JB721TiersHookFlags memory flags = _defaultFlags();
         flags.noNewTiersWithReserves = true;
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
+        (, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
 
         // Try to add a new tier with reserves.
         JB721TierConfig[] memory newTiers = new JB721TierConfig[](1);
@@ -767,7 +763,7 @@ contract Fork_721Hook_Test is Test {
         JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 10, false);
         JB721TiersHookFlags memory flags = _defaultFlags();
         flags.noNewTiersWithOwnerMinting = true;
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
+        (, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
 
         JB721TierConfig[] memory newTiers = new JB721TierConfig[](1);
         newTiers[0] = JB721TierConfig({
@@ -799,7 +795,7 @@ contract Fork_721Hook_Test is Test {
         JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 10, false);
         tierConfigs[0].cannotBeRemoved = true;
         JB721TiersHookFlags memory flags = _defaultFlags();
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
+        (, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
 
         uint256[] memory toRemove = new uint256[](1);
         toRemove[0] = 1;
@@ -864,7 +860,7 @@ contract Fork_721Hook_Test is Test {
         tierConfigs[0].discountPercent = 50;
         tierConfigs[0].cannotIncreaseDiscountPercent = true;
         JB721TiersHookFlags memory flags = _defaultFlags();
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
+        (, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
 
         vm.prank(multisig);
         vm.expectRevert();
@@ -1037,7 +1033,7 @@ contract Fork_721Hook_Test is Test {
         JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 10, true); // allowOwnerMint=true
         tierConfigs[0].reserveFrequency = 0; // No reserves (required: can't have both).
         JB721TiersHookFlags memory flags = _defaultFlags();
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
+        (, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
 
         uint16[] memory tierIds = new uint16[](2);
         tierIds[0] = 1;
@@ -1054,7 +1050,7 @@ contract Fork_721Hook_Test is Test {
         JB721TierConfig[] memory tierConfigs = _makeStandardTiers(1, 10, true);
         tierConfigs[0].reserveFrequency = 0;
         JB721TiersHookFlags memory flags = _defaultFlags();
-        (uint256 projectId, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
+        (, address hook) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
 
         uint16[] memory tierIds = new uint16[](1);
         tierIds[0] = 1;
@@ -1408,7 +1404,7 @@ contract Fork_721Hook_Test is Test {
 
     /// @notice Calling initialize() again on a deployed hook should revert.
     function test_fork_reInitialize_reverts() public {
-        (uint256 projectId, address hook,) = _launchStandardProject();
+        (, address hook,) = _launchStandardProject();
 
         JB721TierConfig[] memory emptyTiers = new JB721TierConfig[](0);
 
@@ -1468,7 +1464,7 @@ contract Fork_721Hook_Test is Test {
 
     /// @notice Non-owner cannot adjustTiers.
     function test_fork_adjustTiers_noPermission_reverts() public {
-        (uint256 projectId, address hook,) = _launchStandardProject();
+        (, address hook,) = _launchStandardProject();
 
         JB721TierConfig[] memory newTiers = new JB721TierConfig[](1);
         newTiers[0] = JB721TierConfig({
@@ -1906,7 +1902,7 @@ contract Fork_721Hook_Test is Test {
         JB721TiersHookFlags memory flags = _defaultFlags();
 
         (uint256 projectId1, address hook1) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
-        (uint256 projectId2, address hook2) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
+        (, address hook2) = _launchProject(tierConfigs, flags, 5000, true, 0x00);
 
         assertTrue(hook1 != hook2, "hooks are different clones");
 
@@ -1989,7 +1985,7 @@ contract Fork_721Hook_Test is Test {
         uint24 category
     )
         internal
-        view
+        pure
         returns (JB721TierConfig memory)
     {
         return JB721TierConfig({

package/test/fork/ERC20TierSplitFork.t.sol

@@ -0,0 +1,539 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+import "forge-std/Test.sol";
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+
+import "@bananapus/core-v6/src/JBController.sol";
+import "@bananapus/core-v6/src/JBDirectory.sol";
+import "@bananapus/core-v6/src/JBMultiTerminal.sol";
+import "@bananapus/core-v6/src/JBFundAccessLimits.sol";
+import "@bananapus/core-v6/src/JBFeelessAddresses.sol";
+import "@bananapus/core-v6/src/JBTerminalStore.sol";
+import "@bananapus/core-v6/src/JBRulesets.sol";
+import "@bananapus/core-v6/src/JBPermissions.sol";
+import "@bananapus/core-v6/src/JBPrices.sol";
+import {JBProjects} from "@bananapus/core-v6/src/JBProjects.sol";
+import "@bananapus/core-v6/src/JBSplits.sol";
+import "@bananapus/core-v6/src/JBERC20.sol";
+import "@bananapus/core-v6/src/JBTokens.sol";
+import "@bananapus/core-v6/src/libraries/JBConstants.sol";
+import "@bananapus/core-v6/src/libraries/JBRulesetMetadataResolver.sol";
+import "@bananapus/core-v6/src/structs/JBAccountingContext.sol";
+import "@bananapus/core-v6/src/structs/JBTerminalConfig.sol";
+import "@bananapus/core-v6/src/structs/JBSplit.sol";
+import "@bananapus/core-v6/src/structs/JBFundAccessLimitGroup.sol";
+import "@bananapus/core-v6/src/interfaces/IJBRulesetApprovalHook.sol";
+import "@bananapus/core-v6/src/interfaces/IJBTerminal.sol";
+import "@bananapus/core-v6/src/interfaces/IJBSplitHook.sol";
+import "@bananapus/permission-ids-v6/src/JBPermissionIds.sol";
+import {MetadataResolverHelper} from "@bananapus/core-v6/test/helpers/MetadataResolverHelper.sol";
+import {JBMetadataResolver} from "@bananapus/core-v6/src/libraries/JBMetadataResolver.sol";
+
+import "@bananapus/address-registry-v6/src/JBAddressRegistry.sol";
+
+import "../../src/JB721TiersHook.sol";
+import "../../src/JB721TiersHookDeployer.sol";
+import "../../src/JB721TiersHookProjectDeployer.sol";
+import "../../src/JB721TiersHookStore.sol";
+import "../../src/interfaces/IJB721TiersHook.sol";
+import "../../src/structs/JBDeploy721TiersHookConfig.sol";
+import "../../src/structs/JBLaunchProjectConfig.sol";
+import "../../src/structs/JBPayDataHookRulesetConfig.sol";
+import "../../src/structs/JBPayDataHookRulesetMetadata.sol";
+
+/// @notice Mock ERC20 with 6 decimals (USDC-like).
+contract MockUSDC6 is ERC20 {
+    constructor() ERC20("Mock USDC", "USDC") {}
+
+    function decimals() public pure override returns (uint8) {
+        return 6;
+    }
+
+    function mint(address to, uint256 amount) external {
+        _mint(to, amount);
+    }
+}
+
+/// @title ERC20TierSplitFork
+/// @notice Fork tests for ERC20 tier split distribution in JB721TiersHook.
+/// @dev Run with: forge test --match-contract ERC20TierSplitFork -vvv --fork-url $RPC
+contract ERC20TierSplitFork is Test {
+    using JBRulesetMetadataResolver for JBRuleset;
+
+    // Actors
+    address multisig = address(0xBEEF);
+    address payer = makeAddr("payer");
+    address beneficiary = makeAddr("beneficiary");
+    address splitBeneficiary = makeAddr("splitBeneficiary");
+    address reserveBeneficiary = makeAddr("reserveBeneficiary");
+
+    // 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;
+
+    // Token
+    MockUSDC6 usdc;
+
+    receive() external payable {}
+
+    function setUp() public {
+        vm.createSelectFork("ethereum");
+
+        _deployJBCore();
+        _deploy721Hook();
+
+        usdc = new MockUSDC6();
+        usdc.mint(payer, 100_000e6);
+
+        vm.deal(payer, 10 ether);
+        vm.deal(multisig, 10 ether);
+    }
+
+    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();
+        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),
+            address(0)
+        );
+
+        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)),
+            address(0)
+        );
+    }
+
+    function _deploy721Hook() internal {
+        store = new JB721TiersHookStore();
+        hookImpl =
+            new JB721TiersHook(jbDirectory, jbPermissions, jbRulesets, store, IJBSplits(address(jbSplits)), 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();
+    }
+
+    // =========================================================================
+    // Launch Helper
+    // =========================================================================
+
+    function _launchERC20Project(
+        JB721TierConfig[] memory tierConfigs,
+        address token,
+        uint8 tokenDecimals
+    )
+        internal
+        returns (uint256 projectId, address dataHook)
+    {
+        uint32 currency = uint32(uint160(token));
+
+        JBDeploy721TiersHookConfig memory hookConfig = JBDeploy721TiersHookConfig({
+            name: "TestNFT",
+            symbol: "TNFT",
+            baseUri: "ipfs://base/",
+            tokenUriResolver: IJB721TokenUriResolver(address(0)),
+            contractUri: "ipfs://contract",
+            tiersConfig: JB721InitTiersConfig({
+                tiers: tierConfigs, currency: currency, decimals: tokenDecimals, prices: IJBPrices(address(0))
+            }),
+            reserveBeneficiary: reserveBeneficiary,
+            flags: JB721TiersHookFlags({
+                preventOverspending: false,
+                issueTokensForSplits: false,
+                noNewTiersWithReserves: false,
+                noNewTiersWithVotes: false,
+                noNewTiersWithOwnerMinting: false
+            })
+        });
+
+        JBPayDataHookRulesetMetadata memory rulesetMetadata = JBPayDataHookRulesetMetadata({
+            reservedPercent: 0,
+            cashOutTaxRate: 0,
+            baseCurrency: currency,
+            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: false,
+            metadata: 0x00
+        });
+
+        JBPayDataHookRulesetConfig[] memory rulesetConfigs = new JBPayDataHookRulesetConfig[](1);
+        rulesetConfigs[0].mustStartAtOrAfter = 0;
+        rulesetConfigs[0].duration = 0;
+        rulesetConfigs[0].weight = 1_000_000e18;
+        rulesetConfigs[0].weightCutPercent = 0;
+        rulesetConfigs[0].approvalHook = IJBRulesetApprovalHook(address(0));
+        rulesetConfigs[0].metadata = rulesetMetadata;
+
+        JBAccountingContext[] memory accountingContexts = new JBAccountingContext[](1);
+        accountingContexts[0] = JBAccountingContext({token: token, currency: currency, decimals: tokenDecimals});
+
+        JBTerminalConfig[] memory terminalConfigs = new JBTerminalConfig[](1);
+        terminalConfigs[0] =
+            JBTerminalConfig({terminal: jbMultiTerminal, accountingContextsToAccept: accountingContexts});
+
+        JBLaunchProjectConfig memory launchConfig = JBLaunchProjectConfig({
+            projectUri: "test-erc20-project",
+            rulesetConfigurations: rulesetConfigs,
+            terminalConfigurations: terminalConfigs,
+            memo: ""
+        });
+
+        IJB721TiersHook hookInstance;
+        (projectId, hookInstance) =
+            projectDeployer.launchProjectFor(multisig, hookConfig, launchConfig, jbController, bytes32(0));
+
+        dataHook = address(hookInstance);
+    }
+
+    /// @dev Launch with ETH accounting (for regression test).
+    function _launchETHProject(JB721TierConfig[] memory tierConfigs)
+        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({
+                tiers: tierConfigs,
+                currency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+                decimals: 18,
+                prices: IJBPrices(address(0))
+            }),
+            reserveBeneficiary: reserveBeneficiary,
+            flags: JB721TiersHookFlags({
+                preventOverspending: false,
+                issueTokensForSplits: false,
+                noNewTiersWithReserves: false,
+                noNewTiersWithVotes: false,
+                noNewTiersWithOwnerMinting: false
+            })
+        });
+
+        JBPayDataHookRulesetMetadata memory rulesetMetadata = JBPayDataHookRulesetMetadata({
+            reservedPercent: 0,
+            cashOutTaxRate: 0,
+            baseCurrency: uint32(uint160(JBConstants.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: false,
+            metadata: 0x00
+        });
+
+        JBPayDataHookRulesetConfig[] memory rulesetConfigs = new JBPayDataHookRulesetConfig[](1);
+        rulesetConfigs[0].mustStartAtOrAfter = 0;
+        rulesetConfigs[0].duration = 0;
+        rulesetConfigs[0].weight = 1_000_000e18;
+        rulesetConfigs[0].weightCutPercent = 0;
+        rulesetConfigs[0].approvalHook = IJBRulesetApprovalHook(address(0));
+        rulesetConfigs[0].metadata = rulesetMetadata;
+
+        JBAccountingContext[] memory accountingContexts = new JBAccountingContext[](1);
+        accountingContexts[0] = JBAccountingContext({
+            token: JBConstants.NATIVE_TOKEN, currency: uint32(uint160(JBConstants.NATIVE_TOKEN)), decimals: 18
+        });
+
+        JBTerminalConfig[] memory terminalConfigs = new JBTerminalConfig[](1);
+        terminalConfigs[0] =
+            JBTerminalConfig({terminal: jbMultiTerminal, accountingContextsToAccept: accountingContexts});
+
+        JBLaunchProjectConfig memory launchConfig = JBLaunchProjectConfig({
+            projectUri: "test-eth-project",
+            rulesetConfigurations: rulesetConfigs,
+            terminalConfigurations: terminalConfigs,
+            memo: ""
+        });
+
+        IJB721TiersHook hookInstance;
+        (projectId, hookInstance) =
+            projectDeployer.launchProjectFor(multisig, hookConfig, launchConfig, jbController, bytes32(0));
+
+        dataHook = address(hookInstance);
+    }
+
+    // =========================================================================
+    // Metadata Helper
+    // =========================================================================
+
+    function _buildPayMetadata(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);
+    }
+
+    function _tokenId(uint256 tierId, uint256 mintNumber) internal pure returns (uint256) {
+        return tierId * 1_000_000_000 + mintNumber;
+    }
+
+    // =========================================================================
+    // Test 1: USDC payment with tier split to beneficiary
+    // =========================================================================
+
+    function test_fork_usdcPayment_tierSplitToBeneficiary() public {
+        // Create a tier: 100 USDC, 30% split to splitBeneficiary.
+        JBSplit[] memory splits = new JBSplit[](1);
+        splits[0] = JBSplit({
+            percent: uint32(JBConstants.SPLITS_TOTAL_PERCENT),
+            projectId: 0,
+            beneficiary: payable(splitBeneficiary),
+            preferAddToBalance: false,
+            lockedUntil: 0,
+            hook: IJBSplitHook(address(0))
+        });
+
+        JB721TierConfig[] memory tierConfigs = new JB721TierConfig[](1);
+        tierConfigs[0] = JB721TierConfig({
+            price: 100e6,
+            initialSupply: 100,
+            votingUnits: 0,
+            reserveFrequency: 0,
+            reserveBeneficiary: address(0),
+            encodedIPFSUri: bytes32("tier1"),
+            category: 1,
+            discountPercent: 0,
+            allowOwnerMint: false,
+            useReserveBeneficiaryAsDefault: false,
+            transfersPausable: false,
+            useVotingUnits: false,
+            cannotBeRemoved: false,
+            cannotIncreaseDiscountPercent: false,
+            splitPercent: 300_000_000, // 30%
+            splits: splits
+        });
+
+        (uint256 projectId, address hook) = _launchERC20Project(tierConfigs, address(usdc), 6);
+
+        // Pay 100 USDC to mint tier 1 NFT.
+        uint16[] memory tierIds = new uint16[](1);
+        tierIds[0] = 1;
+        bytes memory meta = _buildPayMetadata(tierIds, true);
+
+        vm.startPrank(payer);
+        usdc.approve(address(jbMultiTerminal), 100e6);
+        jbMultiTerminal.pay({
+            projectId: projectId,
+            amount: 100e6,
+            token: address(usdc),
+            beneficiary: beneficiary,
+            minReturnedTokens: 0,
+            memo: "",
+            metadata: meta
+        });
+        vm.stopPrank();
+
+        // Split beneficiary should have received 30% of 100 USDC = 30 USDC.
+        assertEq(usdc.balanceOf(splitBeneficiary), 30e6, "split beneficiary should have 30 USDC");
+        // NFT minted to beneficiary.
+        assertEq(IERC721(hook).balanceOf(beneficiary), 1, "beneficiary should own 1 NFT");
+        assertEq(IERC721(hook).ownerOf(_tokenId(1, 1)), beneficiary, "beneficiary owns tier 1 NFT");
+    }
+
+    // =========================================================================
+    // Test 2: USDC payment with tier split to project
+    // =========================================================================
+
+    function test_fork_usdcPayment_tierSplitToProject() public {
+        // First launch a target project that accepts USDC.
+        JB721TierConfig[] memory emptyTiers = new JB721TierConfig[](0);
+        (uint256 targetProjectId,) = _launchERC20Project(emptyTiers, address(usdc), 6);
+
+        // Now create the main project with tier split pointing to target project.
+        JBSplit[] memory splits = new JBSplit[](1);
+        splits[0] = JBSplit({
+            percent: uint32(JBConstants.SPLITS_TOTAL_PERCENT),
+            projectId: uint56(targetProjectId),
+            beneficiary: payable(address(0)),
+            preferAddToBalance: true,
+            lockedUntil: 0,
+            hook: IJBSplitHook(address(0))
+        });
+
+        JB721TierConfig[] memory tierConfigs = new JB721TierConfig[](1);
+        tierConfigs[0] = JB721TierConfig({
+            price: 100e6,
+            initialSupply: 100,
+            votingUnits: 0,
+            reserveFrequency: 0,
+            reserveBeneficiary: address(0),
+            encodedIPFSUri: bytes32("tier1"),
+            category: 1,
+            discountPercent: 0,
+            allowOwnerMint: false,
+            useReserveBeneficiaryAsDefault: false,
+            transfersPausable: false,
+            useVotingUnits: false,
+            cannotBeRemoved: false,
+            cannotIncreaseDiscountPercent: false,
+            splitPercent: 300_000_000, // 30%
+            splits: splits
+        });
+
+        (uint256 projectId, address hook) = _launchERC20Project(tierConfigs, address(usdc), 6);
+
+        // Record target project's terminal USDC balance before.
+        uint256 targetBalanceBefore =
+            jbTerminalStore.balanceOf(address(jbMultiTerminal), targetProjectId, address(usdc));
+
+        // Pay 100 USDC.
+        uint16[] memory tierIds = new uint16[](1);
+        tierIds[0] = 1;
+        bytes memory meta = _buildPayMetadata(tierIds, true);
+
+        vm.startPrank(payer);
+        usdc.approve(address(jbMultiTerminal), 100e6);
+        jbMultiTerminal.pay({
+            projectId: projectId,
+            amount: 100e6,
+            token: address(usdc),
+            beneficiary: beneficiary,
+            minReturnedTokens: 0,
+            memo: "",
+            metadata: meta
+        });
+        vm.stopPrank();
+
+        // Target project should have received 30 USDC via addToBalance.
+        uint256 targetBalanceAfter = jbTerminalStore.balanceOf(address(jbMultiTerminal), targetProjectId, address(usdc));
+        assertEq(targetBalanceAfter - targetBalanceBefore, 30e6, "target project should have 30 USDC more");
+        // NFT minted.
+        assertEq(IERC721(hook).balanceOf(beneficiary), 1, "beneficiary should own 1 NFT");
+    }
+
+    // =========================================================================
+    // Test 3: ETH payment with tier split still works (regression)
+    // =========================================================================
+
+    function test_fork_ethPayment_tierSplitStillWorks() public {
+        JBSplit[] memory splits = new JBSplit[](1);
+        splits[0] = JBSplit({
+            percent: uint32(JBConstants.SPLITS_TOTAL_PERCENT),
+            projectId: 0,
+            beneficiary: payable(splitBeneficiary),
+            preferAddToBalance: false,
+            lockedUntil: 0,
+            hook: IJBSplitHook(address(0))
+        });
+
+        JB721TierConfig[] memory tierConfigs = new JB721TierConfig[](1);
+        tierConfigs[0] = JB721TierConfig({
+            price: 1 ether,
+            initialSupply: 100,
+            votingUnits: 0,
+            reserveFrequency: 0,
+            reserveBeneficiary: address(0),
+            encodedIPFSUri: bytes32("tier1"),
+            category: 1,
+            discountPercent: 0,
+            allowOwnerMint: false,
+            useReserveBeneficiaryAsDefault: false,
+            transfersPausable: false,
+            useVotingUnits: false,
+            cannotBeRemoved: false,
+            cannotIncreaseDiscountPercent: false,
+            splitPercent: 500_000_000, // 50%
+            splits: splits
+        });
+
+        (uint256 projectId, address hook) = _launchETHProject(tierConfigs);
+
+        uint256 splitBalanceBefore = splitBeneficiary.balance;
+
+        // Pay 1 ETH.
+        uint16[] memory tierIds = new uint16[](1);
+        tierIds[0] = 1;
+        bytes memory meta = _buildPayMetadata(tierIds, true);
+
+        vm.prank(payer);
+        jbMultiTerminal.pay{value: 1 ether}({
+            projectId: projectId,
+            amount: 1 ether,
+            token: JBConstants.NATIVE_TOKEN,
+            beneficiary: beneficiary,
+            minReturnedTokens: 0,
+            memo: "",
+            metadata: meta
+        });
+
+        // Split beneficiary should have received 50% of 1 ETH = 0.5 ETH.
+        assertEq(splitBeneficiary.balance - splitBalanceBefore, 0.5 ether, "split beneficiary should have 0.5 ETH");
+        // NFT minted.
+        assertEq(IERC721(hook).balanceOf(beneficiary), 1, "beneficiary should own 1 NFT");
+        assertEq(IERC721(hook).ownerOf(_tokenId(1, 1)), beneficiary, "beneficiary owns tier 1 NFT");
+    }
+}

package/test/invariants/TierLifecycleInvariant.t.sol

@@ -76,7 +76,6 @@ contract TierLifecycleInvariant_Local is StdInvariant, UnitTestSetup {
     function invariant_721_2_totalCashOutWeightConsistency() public {
         uint256 totalWeight = store.totalCashOutWeight(address(hook));
 
-        uint256 maxTierId = store.maxTierIdOf(address(hook));
         uint256 computedWeight = 0;
 
         uint256[] memory categories = new uint256[](0);
@@ -175,7 +174,6 @@ contract TierLifecycleInvariant_Local is StdInvariant, UnitTestSetup {
         JB721Tier[] memory allTiers = store.tiersOf(address(hook), categories, false, 0, 100);
 
         for (uint256 i = 0; i < allTiers.length; i++) {
-            uint256 tierId = allTiers[i].id;
             uint256 price = allTiers[i].price;
 
             // Cash out weight per token for this tier is just `price` (from the store)