@bananapus/721-hook-v6 0.0.1 → 0.0.2

package/src/interfaces/IJB721TiersHook.sol

@@ -1,10 +1,13 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
+import {IJBCashOutHook} from "@bananapus/core-v6/src/interfaces/IJBCashOutHook.sol";
+import {IJBDirectory} from "@bananapus/core-v6/src/interfaces/IJBDirectory.sol";
+import {IJBPayHook} from "@bananapus/core-v6/src/interfaces/IJBPayHook.sol";
 import {IJBPrices} from "@bananapus/core-v6/src/interfaces/IJBPrices.sol";
+import {IJBRulesetDataHook} from "@bananapus/core-v6/src/interfaces/IJBRulesetDataHook.sol";
 import {IJBRulesets} from "@bananapus/core-v6/src/interfaces/IJBRulesets.sol";
 
-import {IJB721Hook} from "./IJB721Hook.sol";
 import {IJB721TiersHookStore} from "./IJB721TiersHookStore.sol";
 import {IJB721TokenUriResolver} from "./IJB721TokenUriResolver.sol";
 import {JB721InitTiersConfig} from "../structs/JB721InitTiersConfig.sol";
@@ -13,7 +16,7 @@ import {JB721TiersHookFlags} from "../structs/JB721TiersHookFlags.sol";
 import {JB721TiersMintReservesConfig} from "../structs/JB721TiersMintReservesConfig.sol";
 import {JB721TiersSetDiscountPercentConfig} from "../structs/JB721TiersSetDiscountPercentConfig.sol";
 
-interface IJB721TiersHook is IJB721Hook {
+interface IJB721TiersHook is IJBRulesetDataHook, IJBPayHook, IJBCashOutHook {
     event AddPayCredits(
         uint256 indexed amount, uint256 indexed newTotalCredits, address indexed account, address caller
     );
@@ -36,6 +39,18 @@ interface IJB721TiersHook is IJB721Hook {
         uint256 indexed amount, uint256 indexed newTotalCredits, address indexed account, address caller
     );
 
+    /// @notice The directory of terminals and controllers for projects.
+    /// @return The directory contract.
+    function DIRECTORY() external view returns (IJBDirectory);
+
+    /// @notice The ID used when parsing metadata.
+    /// @return The address of the metadata ID target.
+    function METADATA_ID_TARGET() external view returns (address);
+
+    /// @notice The ID of the project that this contract is associated with.
+    /// @return The project ID.
+    function PROJECT_ID() external view returns (uint256);
+
     /// @notice The contract storing and managing project rulesets.
     /// @return The rulesets contract.
     function RULESETS() external view returns (IJBRulesets);

package/src/libraries/JB721TiersHookLib.sol

@@ -0,0 +1,336 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import {IJBController} from "@bananapus/core-v6/src/interfaces/IJBController.sol";
+import {IJBDirectory} from "@bananapus/core-v6/src/interfaces/IJBDirectory.sol";
+import {IJBPrices} from "@bananapus/core-v6/src/interfaces/IJBPrices.sol";
+import {IJBSplits} from "@bananapus/core-v6/src/interfaces/IJBSplits.sol";
+import {IJBTerminal} from "@bananapus/core-v6/src/interfaces/IJBTerminal.sol";
+import {JBSplit} from "@bananapus/core-v6/src/structs/JBSplit.sol";
+import {JBConstants} from "@bananapus/core-v6/src/libraries/JBConstants.sol";
+import {JBMetadataResolver} from "@bananapus/core-v6/src/libraries/JBMetadataResolver.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {mulDiv} from "@prb/math/src/Common.sol";
+
+import {JBSplitGroup} from "@bananapus/core-v6/src/structs/JBSplitGroup.sol";
+
+import {IJB721TiersHookStore} from "../interfaces/IJB721TiersHookStore.sol";
+import {JB721TierConfig} from "../structs/JB721TierConfig.sol";
+
+/// @notice External library for JB721TiersHook operations extracted to stay within the EIP-170 contract size limit.
+/// @dev Handles tier adjustments, split calculations, price normalization, and split fund distribution.
+library JB721TiersHookLib {
+    // Events mirrored from IJB721TiersHook (emitted via DELEGATECALL from the hook's context).
+    event AddTier(uint256 indexed tierId, JB721TierConfig tier, address caller);
+    event RemoveTier(uint256 indexed tierId, address caller);
+
+    /// @notice Handles the full tier adjustment logic: removes tiers, adds tiers, emits events, and sets splits.
+    /// @dev Called via DELEGATECALL from the hook, so events are emitted from the hook's address.
+    /// @param store The 721 tiers hook store.
+    /// @param directory The directory to look up controllers.
+    /// @param projectId The project ID.
+    /// @param hookAddress The hook address.
+    /// @param caller The msg.sender of the original call (for event emission).
+    /// @param tiersToAdd The tier configs to add.
+    /// @param tierIdsToRemove The tier IDs to remove.
+    function adjustTiersFor(
+        IJB721TiersHookStore store,
+        IJBDirectory directory,
+        uint256 projectId,
+        address hookAddress,
+        address caller,
+        JB721TierConfig[] calldata tiersToAdd,
+        uint256[] calldata tierIdsToRemove
+    )
+        external
+    {
+        // Remove tiers.
+        if (tierIdsToRemove.length != 0) {
+            for (uint256 i; i < tierIdsToRemove.length; i++) {
+                emit RemoveTier({tierId: tierIdsToRemove[i], caller: caller});
+            }
+            store.recordRemoveTierIds(tierIdsToRemove);
+        }
+
+        // Add tiers.
+        if (tiersToAdd.length != 0) {
+            uint256[] memory tierIdsAdded = store.recordAddTiers(tiersToAdd);
+
+            // slither-disable-next-line reentrancy-events
+            for (uint256 i; i < tiersToAdd.length; i++) {
+                emit AddTier({tierId: tierIdsAdded[i], tier: tiersToAdd[i], caller: caller});
+            }
+
+            // Set split groups for tiers that have splits configured.
+            _setSplitGroupsFor(directory, projectId, hookAddress, tiersToAdd, tierIdsAdded);
+        }
+    }
+
+    /// @notice Normalizes a payment value based on the packed pricing context.
+    /// @param packedPricingContext The packed pricing context (currency, decimals, prices address).
+    /// @param projectId The project ID.
+    /// @param amountValue The payment amount value.
+    /// @param amountCurrency The payment amount currency.
+    /// @param amountDecimals The payment amount decimals.
+    /// @return value The normalized value.
+    /// @return valid Whether the value is valid (false means no prices contract and currencies differ).
+    function normalizePaymentValue(
+        uint256 packedPricingContext,
+        uint256 projectId,
+        uint256 amountValue,
+        uint256 amountCurrency,
+        uint256 amountDecimals
+    )
+        external
+        view
+        returns (uint256 value, bool valid)
+    {
+        uint256 pricingCurrency = uint256(uint32(packedPricingContext));
+        if (amountCurrency == pricingCurrency) return (amountValue, true);
+
+        IJBPrices prices = IJBPrices(address(uint160(packedPricingContext >> 40)));
+        if (address(prices) == address(0)) return (0, false);
+
+        uint256 pricingDecimals = uint256(uint8(packedPricingContext >> 32));
+        value = mulDiv(
+            amountValue,
+            10 ** pricingDecimals,
+            prices.pricePerUnitOf({
+                projectId: projectId,
+                pricingCurrency: amountCurrency,
+                unitCurrency: pricingCurrency,
+                decimals: amountDecimals
+            })
+        );
+        valid = true;
+    }
+
+    /// @notice Calculates per-tier split amounts for a pay event.
+    /// @param store The 721 tiers hook store.
+    /// @param hook The hook address.
+    /// @param metadataIdTarget The metadata ID target for resolving pay metadata.
+    /// @param metadata The payer metadata.
+    /// @return totalSplitAmount The total amount to forward for splits.
+    /// @return hookMetadata Encoded per-tier breakdown (tierIds, amounts) for afterPay.
+    function calculateSplitAmounts(
+        IJB721TiersHookStore store,
+        address hook,
+        address metadataIdTarget,
+        bytes calldata metadata
+    )
+        external
+        view
+        returns (uint256 totalSplitAmount, bytes memory hookMetadata)
+    {
+        bytes memory data;
+        {
+            bool found;
+            (found, data) = JBMetadataResolver.getDataFor(JBMetadataResolver.getId("pay", metadataIdTarget), metadata);
+            if (!found) return (0, bytes(""));
+        }
+
+        (, uint16[] memory tierIdsToMint) = abi.decode(data, (bool, uint16[]));
+        if (tierIdsToMint.length == 0) return (0, bytes(""));
+
+        uint16[] memory splitTierIds = new uint16[](tierIdsToMint.length);
+        uint256[] memory splitAmounts = new uint256[](tierIdsToMint.length);
+        uint256 splitTierCount;
+
+        for (uint256 i; i < tierIdsToMint.length; i++) {
+            // slither-disable-next-line calls-loop
+            uint256 splitPercent = store.tierOf(hook, tierIdsToMint[i], false).splitPercent;
+            if (splitPercent != 0) {
+                // slither-disable-next-line calls-loop
+                uint256 price = store.tierOf(hook, tierIdsToMint[i], false).price;
+                splitTierIds[splitTierCount] = tierIdsToMint[i];
+                splitAmounts[splitTierCount] = mulDiv(price, splitPercent, JBConstants.SPLITS_TOTAL_PERCENT);
+                totalSplitAmount += splitAmounts[splitTierCount];
+                splitTierCount++;
+            }
+        }
+
+        if (splitTierCount != 0) {
+            assembly {
+                mstore(splitTierIds, splitTierCount)
+                mstore(splitAmounts, splitTierCount)
+            }
+            hookMetadata = abi.encode(splitTierIds, splitAmounts);
+        }
+    }
+
+    /// @notice Sets split groups in JBSplits for tiers that have splits configured.
+    function _setSplitGroupsFor(
+        IJBDirectory directory,
+        uint256 projectId,
+        address hookAddress,
+        JB721TierConfig[] calldata tiersToAdd,
+        uint256[] memory tierIdsAdded
+    )
+        private
+    {
+        uint256 splitGroupCount;
+        for (uint256 i; i < tiersToAdd.length; i++) {
+            if (tiersToAdd[i].splits.length != 0) splitGroupCount++;
+        }
+        if (splitGroupCount == 0) return;
+
+        JBSplitGroup[] memory splitGroups = new JBSplitGroup[](splitGroupCount);
+        uint256 groupIndex;
+        for (uint256 i; i < tiersToAdd.length; i++) {
+            if (tiersToAdd[i].splits.length != 0) {
+                splitGroups[groupIndex] = JBSplitGroup({
+                    groupId: uint256(uint160(hookAddress)) | (tierIdsAdded[i] << 160), splits: tiersToAdd[i].splits
+                });
+                groupIndex++;
+            }
+        }
+        IJBController(address(directory.controllerOf(projectId))).SPLITS().setSplitGroupsOf(projectId, 0, splitGroups);
+    }
+
+    /// @notice Distributes forwarded funds for all tiers in the hook metadata.
+    /// @param directory The directory to look up controllers and terminals.
+    /// @param projectId The project ID of the hook.
+    /// @param hookAddress The hook address (for computing split group IDs).
+    /// @param token The token being distributed.
+    /// @param encodedSplitData The encoded per-tier breakdown from hookMetadata.
+    function distributeAll(
+        IJBDirectory directory,
+        uint256 projectId,
+        address hookAddress,
+        address token,
+        bytes calldata encodedSplitData
+    )
+        external
+    {
+        (uint16[] memory tierIds, uint256[] memory amounts) = abi.decode(encodedSplitData, (uint16[], uint256[]));
+
+        IJBSplits splitsContract = IJBController(address(directory.controllerOf(projectId))).SPLITS();
+
+        for (uint256 i; i < tierIds.length; i++) {
+            if (amounts[i] == 0) continue;
+            uint256 groupId = uint256(uint160(hookAddress)) | (uint256(tierIds[i]) << 160);
+            _distributeSingleSplit(directory, splitsContract, projectId, token, groupId, amounts[i]);
+        }
+    }
+
+    /// @notice Distributes funds for a single tier's split group.
+    function _distributeSingleSplit(
+        IJBDirectory directory,
+        IJBSplits splitsContract,
+        uint256 projectId,
+        address token,
+        uint256 groupId,
+        uint256 amount
+    )
+        private
+    {
+        // slither-disable-next-line calls-loop
+        JBSplit[] memory tierSplits = splitsContract.splitsOf(projectId, 0, groupId);
+
+        bool isNativeToken = token == JBConstants.NATIVE_TOKEN;
+        uint256 leftoverPercentage = JBConstants.SPLITS_TOTAL_PERCENT;
+        uint256 leftoverAmount = amount;
+
+        for (uint256 j; j < tierSplits.length; j++) {
+            uint256 payoutAmount = mulDiv(amount, tierSplits[j].percent, leftoverPercentage);
+            if (payoutAmount != 0) {
+                _sendPayoutToSplit(directory, tierSplits[j], token, payoutAmount, isNativeToken);
+                unchecked {
+                    leftoverAmount -= payoutAmount;
+                }
+            }
+            unchecked {
+                leftoverPercentage -= tierSplits[j].percent;
+            }
+        }
+
+        if (leftoverAmount != 0) {
+            _addToBalance(directory, projectId, token, leftoverAmount, isNativeToken);
+        }
+    }
+
+    function _sendPayoutToSplit(
+        IJBDirectory directory,
+        JBSplit memory split,
+        address token,
+        uint256 amount,
+        bool isNativeToken
+    )
+        private
+    {
+        if (split.projectId != 0) {
+            // slither-disable-next-line calls-loop
+            IJBTerminal terminal = directory.primaryTerminalOf(split.projectId, token);
+            if (address(terminal) == address(0)) return;
+
+            if (split.preferAddToBalance) {
+                _terminalAddToBalance(terminal, split.projectId, token, amount, isNativeToken);
+            } else {
+                _terminalPay(terminal, split.projectId, token, amount, split.beneficiary, isNativeToken);
+            }
+        } else if (split.beneficiary != address(0)) {
+            if (isNativeToken) {
+                // slither-disable-next-line arbitrary-send-eth,calls-loop
+                (bool success,) = split.beneficiary.call{value: amount}("");
+                if (!success) revert();
+            } else {
+                SafeERC20.safeTransfer(IERC20(token), split.beneficiary, amount);
+            }
+        }
+    }
+
+    function _addToBalance(
+        IJBDirectory directory,
+        uint256 projectId,
+        address token,
+        uint256 amount,
+        bool isNativeToken
+    )
+        private
+    {
+        // slither-disable-next-line calls-loop
+        IJBTerminal terminal = directory.primaryTerminalOf(projectId, token);
+        if (address(terminal) == address(0)) return;
+        _terminalAddToBalance(terminal, projectId, token, amount, isNativeToken);
+    }
+
+    function _terminalAddToBalance(
+        IJBTerminal terminal,
+        uint256 projectId,
+        address token,
+        uint256 amount,
+        bool isNativeToken
+    )
+        private
+    {
+        if (isNativeToken) {
+            // slither-disable-next-line arbitrary-send-eth,calls-loop
+            terminal.addToBalanceOf{value: amount}(projectId, token, amount, false, "", bytes(""));
+        } else {
+            SafeERC20.forceApprove(IERC20(token), address(terminal), amount);
+            // slither-disable-next-line calls-loop
+            terminal.addToBalanceOf(projectId, token, amount, false, "", bytes(""));
+        }
+    }
+
+    function _terminalPay(
+        IJBTerminal terminal,
+        uint256 projectId,
+        address token,
+        uint256 amount,
+        address beneficiary,
+        bool isNativeToken
+    )
+        private
+    {
+        if (isNativeToken) {
+            // slither-disable-next-line arbitrary-send-eth,unused-return,calls-loop
+            terminal.pay{value: amount}(projectId, token, amount, beneficiary, 0, "", bytes(""));
+        } else {
+            SafeERC20.forceApprove(IERC20(token), address(terminal), amount);
+            // slither-disable-next-line unused-return,calls-loop
+            terminal.pay(projectId, token, amount, beneficiary, 0, "", bytes(""));
+        }
+    }
+}

package/src/structs/JB721Tier.sol

@@ -18,6 +18,8 @@ pragma solidity ^0.8.0;
 /// @custom:member cannotBeRemoved A boolean indicating whether attempts to remove this tier will revert.
 /// @custom:member cannotIncreaseDiscountPercent If the tier cannot have its discount increased.
 /// @custom:member transfersPausable A boolean indicating whether transfers for NFTs in tier can be paused.
+/// @custom:member splitPercent The percentage of the tier's price that gets routed to the project's split group when
+/// an NFT from this tier is minted. Out of `JBConstants.SPLITS_TOTAL_PERCENT`.
 /// @custom:member resolvedUri A resolved token URI for NFTs in this tier. Only available if the NFT this tier belongs
 /// to has a resolver.
 struct JB721Tier {
@@ -35,5 +37,6 @@ struct JB721Tier {
     bool transfersPausable;
     bool cannotBeRemoved;
     bool cannotIncreaseDiscountPercent;
+    uint32 splitPercent;
     string resolvedUri;
 }

package/src/structs/JB721TierConfig.sol

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
+import {JBSplit} from "@bananapus/core-v6/src/structs/JBSplit.sol";
+
 /// @notice Config for a single NFT tier within a `JB721TiersHook`.
 /// @custom:member price The price to buy an NFT in this tier, in terms of the currency in its `JBInitTiersConfig`.
 /// @custom:member initialSupply The total number of NFTs which can be minted from this tier.
@@ -22,6 +24,10 @@ pragma solidity ^0.8.0;
 /// power. If `useVotingUnits` is false, voting power is based on the tier's price.
 /// @custom:member cannotBeRemoved If the tier cannot be removed once added.
 /// @custom:member cannotIncreaseDiscount If the tier cannot have its discount increased.
+/// @custom:member splitPercent The percentage of the tier's price that gets routed to the tier's split group when
+/// an NFT from this tier is minted. Out of `JBConstants.SPLITS_TOTAL_PERCENT`.
+/// @custom:member splits The splits to use for this tier's split group. These define where the split portion of the
+/// tier's price gets routed when an NFT from this tier is minted.
 struct JB721TierConfig {
     uint104 price;
     uint32 initialSupply;
@@ -37,4 +43,6 @@ struct JB721TierConfig {
     bool useVotingUnits;
     bool cannotBeRemoved;
     bool cannotIncreaseDiscountPercent;
+    uint32 splitPercent;
+    JBSplit[] splits;
 }

package/src/structs/JBStored721Tier.sol

@@ -4,19 +4,20 @@ pragma solidity ^0.8.0;
 /// @custom:member price The price to buy an NFT in this tier, in terms of the currency in its `JBInitTiersConfig`.
 /// @custom:member remainingSupply The remaining number of NFTs which can be minted from this tier.
 /// @custom:member initialSupply The total number of NFTs which can be minted from this tier.
-/// @custom:member votingUnits The number of votes that each NFT in this tier gets.
+/// @custom:member splitPercent The percentage of the tier's price that gets routed to the tier's split group when
+/// an NFT from this tier is minted. Out of `JBConstants.SPLITS_TOTAL_PERCENT`.
 /// @custom:member category The category that NFTs in this tier belongs to. Used to group NFT tiers.
 /// @custom:member discountPercent The discount that should be applied to the tier.
 /// @custom:member reserveFrequency The frequency at which an extra NFT is minted for the `reserveBeneficiary` from this
 /// tier. With a `reserveFrequency` of 5, an extra NFT will be minted for the `reserveBeneficiary` for every 5 NFTs
 /// purchased.
-/// @custom:member packedBools A packed uint8 containing boolean flags: bit 0 = allowOwnerMint, bit 1 =
-/// transfersPausable, bit 2 = useVotingUnits, bit 3 = cannotBeRemoved, bit 4 = cannotIncreaseDiscountPercent.
+/// @custom:member packedBools Packed boolean flags: allowOwnerMint, transfersPausable, useVotingUnits,
+/// cannotBeRemoved, cannotIncreaseDiscountPercent.
 struct JBStored721Tier {
     uint104 price;
     uint32 remainingSupply;
     uint32 initialSupply;
-    uint32 votingUnits;
+    uint32 splitPercent;
     uint24 category;
     uint8 discountPercent;
     uint16 reserveFrequency;

package/test/721HookAttacks.t.sol

@@ -85,7 +85,9 @@ contract NFTHookAttacks is UnitTestSetup {
             transfersPausable: false,
             cannotBeRemoved: false,
             cannotIncreaseDiscountPercent: false,
-            useVotingUnits: false
+            useVotingUnits: false,
+            splitPercent: 0,
+            splits: new JBSplit[](0)
         });
 
         vm.prank(owner);
@@ -370,7 +372,9 @@ contract NFTHookAttacks is UnitTestSetup {
             transfersPausable: false,
             cannotBeRemoved: false,
             cannotIncreaseDiscountPercent: false,
-            useVotingUnits: false
+            useVotingUnits: false,
+            splitPercent: 0,
+            splits: new JBSplit[](0)
         });
 
         vm.prank(attacker);

package/test/E2E/Pay_Mint_Redeem_E2E.t.sol

@@ -778,7 +778,9 @@ contract Test_TiersHook_E2E is TestBaseWorkflow {
                 transfersPausable: false,
                 useVotingUnits: false,
                 cannotBeRemoved: false,
-                cannotIncreaseDiscountPercent: false
+                cannotIncreaseDiscountPercent: false,
+                splitPercent: 0,
+                splits: new JBSplit[](0)
             });
         }
         tiersHookConfig = JBDeploy721TiersHookConfig({
@@ -869,7 +871,9 @@ contract Test_TiersHook_E2E is TestBaseWorkflow {
             transfersPausable: false,
             useVotingUnits: false,
             cannotBeRemoved: false,
-            cannotIncreaseDiscountPercent: false
+            cannotIncreaseDiscountPercent: false,
+            splitPercent: 0,
+            splits: new JBSplit[](0)
         });
 
         tiersHookConfig = JBDeploy721TiersHookConfig({

package/test/invariants/handlers/TierLifecycleHandler.sol

@@ -163,7 +163,9 @@ contract TierLifecycleHandler is Test {
             transfersPausable: false,
             useVotingUnits: false,
             cannotBeRemoved: false,
-            cannotIncreaseDiscountPercent: false
+            cannotIncreaseDiscountPercent: false,
+            splitPercent: 0,
+            splits: new JBSplit[](0)
         });
 
         vm.prank(hookAddress);

package/test/invariants/handlers/TierStoreHandler.sol

@@ -8,6 +8,7 @@ import {StdUtils} from "forge-std/StdUtils.sol";
 import {JB721TiersHookStore} from "../../../src/JB721TiersHookStore.sol";
 import {JB721TierConfig} from "../../../src/structs/JB721TierConfig.sol";
 import {JB721TiersHookFlags} from "../../../src/structs/JB721TiersHookFlags.sol";
+import {JBSplit} from "@bananapus/core-v6/src/structs/JBSplit.sol";
 
 /// @notice Handler for JB721TiersHookStore invariant tests.
 /// @dev Acts as the "hook" address itself, so msg.sender (this) == hook in the store.
@@ -61,7 +62,9 @@ contract TierStoreHandler is CommonBase, StdCheats, StdUtils {
             transfersPausable: false,
             useVotingUnits: false,
             cannotBeRemoved: false,
-            cannotIncreaseDiscountPercent: false
+            cannotIncreaseDiscountPercent: false,
+            splitPercent: 0,
+            splits: new JBSplit[](0)
         });
 
         try this._doAddTiers(configs) {