@bananapus/721-hook-v6 0.0.32 → 0.0.33

package/src/interfaces/IJB721TiersHook.sol

@@ -6,6 +6,8 @@ import {IJBRulesets} from "@bananapus/core-v6/src/interfaces/IJBRulesets.sol";
 import {IJBSplits} from "@bananapus/core-v6/src/interfaces/IJBSplits.sol";
 import {JBSplit} from "@bananapus/core-v6/src/structs/JBSplit.sol";
 
+import {IJB721Checkpoints} from "./IJB721Checkpoints.sol";
+import {IJB721CheckpointsDeployer} from "./IJB721CheckpointsDeployer.sol";
 import {IJB721Hook} from "./IJB721Hook.sol";
 import {IJB721TiersHookStore} from "./IJB721TiersHookStore.sol";
 import {IJB721TokenUriResolver} from "./IJB721TokenUriResolver.sol";
@@ -144,6 +146,12 @@ interface IJB721TiersHook is IJB721Hook {
     /// @return decimals The amount of decimals being used in tier prices.
     function pricingContext() external view returns (uint256 currency, uint256 decimals);
 
+    /// @notice The checkpoint module that manages IVotes-compatible checkpointed voting power for this hook's NFTs.
+    /// @dev Deployed lazily on first mint. Pass this to JBTokenDistributor as the IVotes token.
+    /// @return The checkpoint module.
+    // forge-lint: disable-next-line(mixed-case-function)
+    function CHECKPOINTS() external view returns (IJB721Checkpoints);
+
     /// @notice The contract that exposes price feeds for currency conversions.
     /// @return The prices contract.
     function PRICES() external view returns (IJBPrices);

package/src/libraries/JB721TiersHookLib.sol

@@ -310,6 +310,10 @@ library JB721TiersHookLib {
         convertedTotal = totalSplitAmount;
         convertedMetadata = splitMetadata;
 
+        // Extract pricing decimals for reuse below.
+        // forge-lint: disable-next-line(unsafe-typecast)
+        uint256 pricingDecimals = uint256(uint8(packedPricingContext >> 32));
+
         // Convert each per-tier amount from the tier pricing currency to the payment currency.
         // forge-lint: disable-next-line(unsafe-typecast)
         if (amountCurrency != uint256(uint32(packedPricingContext))) {
@@ -329,8 +333,7 @@ library JB721TiersHookLib {
                 });
 
                 // The denominator scales each amount from tier-pricing decimals to payment-token decimals.
-                // forge-lint: disable-next-line(unsafe-typecast)
-                uint256 denom = 10 ** uint256(uint8(packedPricingContext >> 32));
+                uint256 denom = 10 ** pricingDecimals;
 
                 // Decode per-tier breakdown so each amount can be converted individually.
                 (uint16[] memory tierIds, uint256[] memory amounts) =
@@ -351,6 +354,35 @@ library JB721TiersHookLib {
                 // Re-encode with the converted amounts.
                 convertedMetadata = abi.encode(tierIds, amounts);
             }
+        } else if (amountDecimals != pricingDecimals) {
+            // Same currency but different decimal scales (e.g. pricing at 18 decimals, payment token at 6).
+            // Without this branch, split amounts stay in pricing decimals while the cap comparison uses
+            // payment decimals — causing orders-of-magnitude mis-scaling. This mirrors the same-currency
+            // decimal adjustment in `normalizePaymentValue` (which handles the mint path).
+
+            // Decode the per-tier breakdown so each amount can be rescaled individually.
+            (uint16[] memory tierIds, uint256[] memory amounts) = abi.decode(convertedMetadata, (uint16[], uint256[]));
+
+            // Re-accumulate the total from rescaled amounts to avoid rounding drift.
+            convertedTotal = 0;
+            for (uint256 i; i < amounts.length;) {
+                // Scale each amount from pricing decimals to payment decimals.
+                if (amountDecimals > pricingDecimals) {
+                    // Payment has more decimals — multiply to add precision (e.g. 6→18: multiply by 10^12).
+                    amounts[i] = amounts[i] * (10 ** (amountDecimals - pricingDecimals));
+                } else {
+                    // Payment has fewer decimals — divide to remove precision (e.g. 18→6: divide by 10^12).
+                    amounts[i] = amounts[i] / (10 ** (pricingDecimals - amountDecimals));
+                }
+                convertedTotal += amounts[i];
+
+                unchecked {
+                    ++i;
+                }
+            }
+
+            // Re-encode with the rescaled amounts.
+            convertedMetadata = abi.encode(tierIds, amounts);
         }
 
         // Cap the total at the actual payment value. Pay credits fund NFT minting (virtual), but splits
@@ -770,4 +802,23 @@ library JB721TiersHookLib {
                 baseUri: baseUri, hexString: store.encodedTierIPFSUriOf({hook: hook, tokenId: tokenId})
             });
     }
+
+    event SetDiscountPercent(uint256 indexed tierId, uint256 discountPercent, address caller);
+
+    /// @notice Set the discount percent for a tier, emitting an event and recording it in the store.
+    /// @param store The 721 tiers hook store.
+    /// @param tierId The ID of the tier.
+    /// @param discountPercent The discount percent to set.
+    /// @param caller The msg.sender of the original call.
+    function setDiscountPercentOf(
+        IJB721TiersHookStore store,
+        uint256 tierId,
+        uint256 discountPercent,
+        address caller
+    )
+        external
+    {
+        emit SetDiscountPercent({tierId: tierId, discountPercent: discountPercent, caller: caller});
+        store.recordSetDiscountPercentOf({tierId: tierId, discountPercent: discountPercent});
+    }
 }

package/test/E2E/Pay_Mint_Redeem_E2E.t.sol

@@ -15,6 +15,9 @@ import "../../src/JB721TiersHookDeployer.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 "../utils/TestBaseWorkflow.sol";
 // forge-lint: disable-next-line(unaliased-plain-import)
@@ -69,7 +72,14 @@ contract Test_TiersHook_E2E is TestBaseWorkflow {
         super.setUp();
         store = new JB721TiersHookStore();
         hook = new JB721TiersHook(
-            jbDirectory, jbPermissions, jbPrices, jbRulesets, store, IJBSplits(address(jbSplits)), trustedForwarder
+            jbDirectory,
+            jbPermissions,
+            jbPrices,
+            jbRulesets,
+            store,
+            IJBSplits(address(jbSplits)),
+            IJB721CheckpointsDeployer(address(new JB721CheckpointsDeployer())),
+            trustedForwarder
         );
         addressRegistry = new JBAddressRegistry();
         JB721TiersHookDeployer hookDeployer = new JB721TiersHookDeployer(hook, store, addressRegistry, trustedForwarder);

package/test/Fork.t.sol

@@ -66,6 +66,8 @@ import "../src/JB721TiersHookDeployer.sol";
 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)
@@ -183,7 +185,7 @@ contract Fork_721Hook_Test is Test {
         jbPermissions = new JBPermissions(address(0));
         jbProjects = new JBProjects(multisig, address(0), address(0));
         jbDirectory = new JBDirectory(jbPermissions, jbProjects, multisig);
-        JBERC20 jbErc20 = new JBERC20();
+        JBERC20 jbErc20 = new JBERC20(jbPermissions, jbProjects);
         jbTokens = new JBTokens(jbDirectory, jbErc20);
         jbRulesets = new JBRulesets(jbDirectory);
         jbPrices = new JBPrices(jbDirectory, jbPermissions, jbProjects, multisig, address(0));
@@ -231,7 +233,14 @@ contract Fork_721Hook_Test is Test {
     function _deploy721Hook() internal {
         store = new JB721TiersHookStore();
         hookImpl = new JB721TiersHook(
-            jbDirectory, jbPermissions, jbPrices, jbRulesets, store, IJBSplits(address(jbSplits)), address(0)
+            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));

package/test/TestAuditGaps.sol

@@ -164,7 +164,7 @@ contract TestAuditGaps_Reentrancy is UnitTestSetup {
             weight: 10e18,
             newlyIssuedTokenCount: 0,
             beneficiary: beneficiary,
-            hookMetadata: abi.encode(splitTierIds, splitAmounts),
+            hookMetadata: abi.encode(beneficiary, beneficiary, abi.encode(splitTierIds, splitAmounts)),
             payerMetadata: payerMetadata
         });
     }

package/test/TestCheckpoints.t.sol

@@ -0,0 +1,329 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.28;
+
+// forge-lint: disable-next-line(unaliased-plain-import)
+import "./utils/UnitTestSetup.sol";
+// forge-lint: disable-next-line(unaliased-plain-import)
+import "./utils/ForTest_JB721TiersHook.sol";
+import {JB721Checkpoints} from "../src/JB721Checkpoints.sol";
+import {IJB721Checkpoints} from "../src/interfaces/IJB721Checkpoints.sol";
+import {IJB721TiersHook} from "../src/interfaces/IJB721TiersHook.sol";
+import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+
+/// @title TestCheckpoints
+/// @notice Tests the checkpoint module IVotes checkpointed voting power baked into the base hook:
+/// delegation, checkpoints, transfer, multi-tier, burn, and module deployment.
+contract TestCheckpoints is UnitTestSetup {
+    /// @notice Deploys a ForTest hook with the given number of tiers.
+    function _initializeHookWithCheckpoints(uint256 numberOfTiers) internal returns (ForTest_JB721TiersHook tiersHook) {
+        (JB721TierConfig[] memory tierConfigs,) = _createTiers(defaultTierConfig, numberOfTiers);
+
+        ForTest_JB721TiersHookStore hookStore = new ForTest_JB721TiersHookStore();
+
+        tiersHook = new ForTest_JB721TiersHook(
+            ForTest_JB721TiersHook.ForTestInitConfig({
+                projectId: projectId,
+                name: name,
+                symbol: symbol,
+                baseUri: baseUri,
+                tokenUriResolver: IJB721TokenUriResolver(mockTokenUriResolver),
+                contractUri: contractUri,
+                tiers: tierConfigs,
+                flags: JB721TiersHookFlags({
+                    preventOverspending: false,
+                    issueTokensForSplits: false,
+                    noNewTiersWithReserves: false,
+                    noNewTiersWithVotes: false,
+                    noNewTiersWithOwnerMinting: true
+                })
+            }),
+            IJBDirectory(mockJBDirectory),
+            IJBPrices(mockJBPrices),
+            IJBRulesets(mockJBRulesets),
+            IJB721TiersHookStore(address(hookStore)),
+            IJBSplits(mockJBSplits)
+        );
+
+        tiersHook.transferOwnership(owner);
+    }
+
+    // -------------------------------------------------------------------
+    // Test 1: Checkpoint module is deployed eagerly during initialize
+    // -------------------------------------------------------------------
+    function test_checkpointModule_isDeployed() public {
+        defaultTierConfig.flags.allowOwnerMint = true;
+        defaultTierConfig.reserveFrequency = 0;
+
+        ForTest_JB721TiersHook tiersHook = _initializeHookWithCheckpoints(1);
+
+        // CHECKPOINTS should be deployed immediately after initialization.
+        assertTrue(
+            address(tiersHook.CHECKPOINTS()) != address(0), "Checkpoint module should be deployed after initialization"
+        );
+    }
+
+    // -------------------------------------------------------------------
+    // Test 2: supportsInterface still works for base hook
+    // -------------------------------------------------------------------
+    function test_supportsInterface() public {
+        defaultTierConfig.flags.allowOwnerMint = true;
+        defaultTierConfig.reserveFrequency = 0;
+
+        ForTest_JB721TiersHook tiersHook = _initializeHookWithCheckpoints(1);
+
+        assertTrue(tiersHook.supportsInterface(type(IJB721TiersHook).interfaceId), "Should support IJB721TiersHook");
+    }
+
+    // -------------------------------------------------------------------
+    // Test 3: Mint + manual delegate -> getVotes equals tier votingUnits
+    // -------------------------------------------------------------------
+    function test_mintAndDelegate_getVotes() public {
+        defaultTierConfig.flags.allowOwnerMint = true;
+        defaultTierConfig.reserveFrequency = 0;
+        defaultTierConfig.flags.useVotingUnits = true;
+        defaultTierConfig.votingUnits = 100;
+
+        ForTest_JB721TiersHook tiersHook = _initializeHookWithCheckpoints(1);
+
+        address user = makeAddr("user");
+
+        // Mint an NFT to user (CHECKPOINTS already deployed during init).
+        uint16[] memory tiersToMint = new uint16[](1);
+        tiersToMint[0] = 1;
+        vm.prank(owner);
+        tiersHook.mintFor(tiersToMint, user);
+
+        IJB721Checkpoints module = tiersHook.CHECKPOINTS();
+
+        // Without delegation, getVotes should be 0.
+        assertEq(module.getVotes(user), 0, "Votes should be 0 before delegation");
+
+        // User self-delegates.
+        vm.prank(user);
+        module.delegate(user);
+
+        assertEq(module.getVotes(user), 100, "Votes should be 100 after delegation");
+    }
+
+    // -------------------------------------------------------------------
+    // Test 4: No auto-delegation — delegates(user) stays address(0) after mint
+    // -------------------------------------------------------------------
+    function test_noAutoDelegation_delegateStaysZero() public {
+        defaultTierConfig.flags.allowOwnerMint = true;
+        defaultTierConfig.reserveFrequency = 0;
+        defaultTierConfig.flags.useVotingUnits = true;
+        defaultTierConfig.votingUnits = 100;
+
+        ForTest_JB721TiersHook tiersHook = _initializeHookWithCheckpoints(1);
+
+        address user = makeAddr("user");
+
+        // Mint an NFT to user (CHECKPOINTS already deployed during init).
+        uint16[] memory tiersToMint = new uint16[](1);
+        tiersToMint[0] = 1;
+        vm.prank(owner);
+        tiersHook.mintFor(tiersToMint, user);
+
+        IJB721Checkpoints module = tiersHook.CHECKPOINTS();
+
+        // Delegate should be address(0) — no auto-delegation.
+        assertEq(module.delegates(user), address(0), "Delegate should be zero after mint");
+    }
+
+    // -------------------------------------------------------------------
+    // Test 5: Transfer moves checkpointed votes (with manual delegation)
+    // -------------------------------------------------------------------
+    function test_transfer_movesCheckpointedVotes() public {
+        defaultTierConfig.flags.allowOwnerMint = true;
+        defaultTierConfig.reserveFrequency = 0;
+        defaultTierConfig.flags.useVotingUnits = true;
+        defaultTierConfig.votingUnits = 100;
+
+        ForTest_JB721TiersHook tiersHook = _initializeHookWithCheckpoints(1);
+
+        address alice = makeAddr("alice");
+        address bob = makeAddr("bob");
+
+        // Mint to alice (CHECKPOINTS already deployed during init).
+        uint16[] memory tiersToMint = new uint16[](1);
+        tiersToMint[0] = 1;
+        vm.prank(owner);
+        tiersHook.mintFor(tiersToMint, alice);
+
+        IJB721Checkpoints module = tiersHook.CHECKPOINTS();
+
+        // Both delegate to themselves.
+        vm.prank(alice);
+        module.delegate(alice);
+        vm.prank(bob);
+        module.delegate(bob);
+
+        assertEq(module.getVotes(alice), 100, "Alice should have 100 votes");
+        assertEq(module.getVotes(bob), 0, "Bob should have 0 votes");
+
+        // Transfer NFT from alice to bob.
+        uint256 tokenId = _generateTokenId(1, 1);
+        vm.prank(alice);
+        IERC721(address(tiersHook)).transferFrom(alice, bob, tokenId);
+
+        assertEq(module.getVotes(alice), 0, "Alice should have 0 votes after transfer");
+        assertEq(module.getVotes(bob), 100, "Bob should have 100 votes after transfer");
+    }
+
+    // -------------------------------------------------------------------
+    // Test 6: getPastVotes / getPastTotalSupply checkpoints
+    // -------------------------------------------------------------------
+    function test_getPastVotes_checkpoint() public {
+        defaultTierConfig.flags.allowOwnerMint = true;
+        defaultTierConfig.reserveFrequency = 0;
+        defaultTierConfig.flags.useVotingUnits = true;
+        defaultTierConfig.votingUnits = 100;
+
+        ForTest_JB721TiersHook tiersHook = _initializeHookWithCheckpoints(1);
+
+        address user = makeAddr("user");
+
+        // Mint first NFT to test checkpoint tracking.
+        uint16[] memory tiersToMint = new uint16[](1);
+        tiersToMint[0] = 1;
+        vm.prank(owner);
+        tiersHook.mintFor(tiersToMint, user);
+
+        IJB721Checkpoints module = tiersHook.CHECKPOINTS();
+
+        // User self-delegates so checkpoints are created going forward.
+        vm.prank(user);
+        module.delegate(user);
+
+        uint256 blockBeforeSecondMint = block.number;
+        vm.roll(block.number + 1);
+
+        // Mint a second NFT.
+        vm.prank(owner);
+        tiersHook.mintFor(tiersToMint, user);
+
+        uint256 blockAfterSecondMint = block.number;
+        vm.roll(block.number + 1);
+
+        // Past votes before second mint = 100 (from first NFT + delegation).
+        assertEq(module.getPastVotes(user, blockBeforeSecondMint), 100, "Past votes before second mint should be 100");
+        // Past votes after second mint = 200.
+        assertEq(module.getPastVotes(user, blockAfterSecondMint), 200, "Past votes after second mint should be 200");
+
+        // Past total supply.
+        assertEq(
+            module.getPastTotalSupply(blockBeforeSecondMint), 100, "Past total supply before second mint should be 100"
+        );
+        assertEq(
+            module.getPastTotalSupply(blockAfterSecondMint), 200, "Past total supply after second mint should be 200"
+        );
+    }
+
+    // -------------------------------------------------------------------
+    // Test 7: Multi-tier with different voting units
+    // -------------------------------------------------------------------
+    function test_multiTier_differentVotingUnits() public {
+        defaultTierConfig.flags.allowOwnerMint = true;
+        defaultTierConfig.reserveFrequency = 0;
+        defaultTierConfig.flags.useVotingUnits = true;
+
+        ForTest_JB721TiersHook tiersHook = _initializeHookWithCheckpoints(3);
+
+        // Set custom voting units per tier.
+        tiersHook.test_store().ForTest_setTierVotingUnits(address(tiersHook), 1, 100);
+        tiersHook.test_store().ForTest_setTierVotingUnits(address(tiersHook), 2, 200);
+        tiersHook.test_store().ForTest_setTierVotingUnits(address(tiersHook), 3, 500);
+
+        address user = makeAddr("user");
+
+        // Mint one from tier 1 to test checkpoint tracking.
+        uint16[] memory tier1 = new uint16[](1);
+        tier1[0] = 1;
+        vm.prank(owner);
+        tiersHook.mintFor(tier1, user);
+
+        IJB721Checkpoints module = tiersHook.CHECKPOINTS();
+
+        // User self-delegates.
+        vm.prank(user);
+        module.delegate(user);
+
+        // Mint from remaining tiers.
+        uint16[] memory tier2 = new uint16[](1);
+        tier2[0] = 2;
+        uint16[] memory tier3 = new uint16[](1);
+        tier3[0] = 3;
+
+        vm.startPrank(owner);
+        tiersHook.mintFor(tier2, user);
+        tiersHook.mintFor(tier3, user);
+        vm.stopPrank();
+
+        // 100 + 200 + 500 = 800.
+        assertEq(module.getVotes(user), 800, "User should have 800 checkpointed votes");
+    }
+
+    // -------------------------------------------------------------------
+    // Test 8: Burn decreases checkpointed total supply
+    // -------------------------------------------------------------------
+    function test_burn_decreasesTotalSupply() public {
+        defaultTierConfig.flags.allowOwnerMint = true;
+        defaultTierConfig.reserveFrequency = 0;
+        defaultTierConfig.flags.useVotingUnits = true;
+        defaultTierConfig.votingUnits = 100;
+
+        ForTest_JB721TiersHook tiersHook = _initializeHookWithCheckpoints(1);
+
+        address user = makeAddr("user");
+
+        // Mint 2 NFTs (first one deploys CHECKPOINTS lazily).
+        uint16[] memory tiersToMint = new uint16[](2);
+        tiersToMint[0] = 1;
+        tiersToMint[1] = 1;
+        vm.prank(owner);
+        tiersHook.mintFor(tiersToMint, user);
+
+        IJB721Checkpoints module = tiersHook.CHECKPOINTS();
+
+        // User self-delegates.
+        vm.prank(user);
+        module.delegate(user);
+
+        assertEq(module.getVotes(user), 200, "User should have 200 votes from 2 NFTs");
+
+        uint256 blockBeforeBurn = block.number;
+        vm.roll(block.number + 1);
+
+        // Burn one NFT.
+        uint256[] memory tokensToBurn = new uint256[](1);
+        tokensToBurn[0] = _generateTokenId(1, 1);
+        tiersHook.burn(tokensToBurn);
+
+        assertEq(module.getVotes(user), 100, "User should have 100 votes after burning 1 NFT");
+
+        vm.roll(block.number + 1);
+
+        assertEq(module.getPastTotalSupply(blockBeforeBurn), 200, "Past total supply before burn should be 200");
+    }
+
+    // -------------------------------------------------------------------
+    // Test 9: Unauthorized onTransfer reverts
+    // -------------------------------------------------------------------
+    function test_unauthorizedOnTransfer_reverts() public {
+        defaultTierConfig.flags.allowOwnerMint = true;
+        defaultTierConfig.reserveFrequency = 0;
+
+        ForTest_JB721TiersHook tiersHook = _initializeHookWithCheckpoints(1);
+
+        // Mint to test checkpoint tracking.
+        uint16[] memory tiersToMint = new uint16[](1);
+        tiersToMint[0] = 1;
+        vm.prank(owner);
+        tiersHook.mintFor(tiersToMint, makeAddr("user"));
+
+        IJB721Checkpoints module = tiersHook.CHECKPOINTS();
+
+        vm.expectRevert(JB721Checkpoints.JB721Checkpoints_Unauthorized.selector);
+        module.onTransfer(address(0), address(1), 1);
+    }
+}